@prodero/curator 0.2.1 → 0.3.0

package/ARCHITECTURE.md

@@ -1,5 +1,13 @@
 # Prodero Architecture
 
+## 0.3.0 development: quiet session maintenance
+
+Ordinary Open/Prepare/Close and visual/CLI navigation no longer expose a memory moderation queue. Existing deterministic synchronization owns snapshot recovery, conservative consolidation, provenance and transactional checkpoints. Legacy curation APIs retain their low-level source/approval contracts for technical compatibility; persisted questions/candidates are not accepted, dismissed or deleted by UI removal.
+
+Prepare can offer the current host agent one bounded `prodero_session_reconcile_prepare` / `prodero_session_reconcile_propose` task. Its immutable job binds the active prepared session, latest native task/scope fingerprint, authorized retrieval or task-dispute evidence and canonical revisions. Source prose is untrusted evidence, never authority. Complete semantic coverage and existing lifecycle transactions permit only justified eligible Local inferred State/Lesson changes. Protected/shared/rule changes, metadata loss, unsupported scope changes and unresolved intent preserve originals. Supersession additionally needs an existing replacement edge and matching boundaries. Exact retry reuses the receipt; invalid reasoning consumes the attempt; confirmed changes refresh the original task context once.
+
+There is no additional model provider or credential. Real save/storage/recovery errors and current-task Required blockers remain visible. Optional planning signals and pending housekeeping do not create user decisions. Explicit selected Knowledge sharing/editing and migrations retain their own exact approvals. The general chat renderer style remains separate from this behavior change.
+
 ## Primary experience
 
 Users interact with Prodero primarily through their coding agent.
@@ -296,3 +304,7 @@ Only potential_conflict uses warning styling. State transitions say “Knowledge
 ## Migration Foundation
 
 Project structure and canonical knowledge have independent versions under `.prodero/config.json`. The existing Core migration engine owns ordered planning, approval-bound execution, staging, backup integrity, shared locking, rollback and diagnostic history. Open, Prepare, MCP/text and CLI consume that engine. See [Migration Foundation](docs/MIGRATIONS.md) for version transitions and lifecycle boundaries.
+
+## Chat text boundary — 0.3.0 development
+
+`src/chat-text.ts` renders native Markdown from the existing ViewModel/conversation projection, without I/O, capability guessing or business mutations. `renderText` selects that chat route by default; `renderTerminalText` and explicit MCP `plain:true` retain the existing width-bounded terminal route in `src/text-layout.ts`. CLI migration calls the terminal route explicitly. The MCP gateway and invisible-App fallback share the Markdown output while App negotiation/actions remain unchanged. Chat returns named actions and exact knowledge bindings; numbered aliases are supplied only with the explicitly displayed terminal fallback. Exact review/source/code bodies and diagnostics retain literal preservation; no interface is fenced. Missing counts, Required blockers, deferred saving and errors remain factual. The runtime guide, not a duplicate global launcher policy, owns the relay/translation contract.

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.3.0 — 2026-11-09 (Public Preview)
+
+- Updated MCP SDK to 1.32.2, refreshed compatible production dependency patches, and migrated validators to Zod 4.6.7. Bounded collections now reject oversized input before walking elements; provider/plugin JSON Schema and legacy input defaults/receipts retain their validation contracts.
+
+- Open navigation preserves filtered catalogue pages on detail return, reports Initialize failures truthfully, clears completed sharing selections and retains confirmed Apply receipts across refresh errors. Unavailable/cached catalogues are explicit and cannot masquerade as empty current data.
+
+- Compact text Open now shows branch lines with total/Local/Versioned memory and actual bootstrap instruction counts. Four stable numbered actions support natural-language requests and clearly distinguish legacy instruction refinement from sharing memory via Git.
+
+- Installation examples now follow npm `@latest`; the agent resolves and reviews one exact release before installing, so the stable prompt needs no version edit on future releases.
+- Added an optional prompt-assisted installation guide, with current-stable wizard fallback and a landing Copy prompt publication handoff. Manual npm/CLI installation remains supported.
+- Added explicit one-host installation preview/apply for agents, reusing existing native configuration ownership, backups and recovery. Saved configuration and pending restart/connectivity remain distinct.
+- Added an approved prerequisite preparation path to the installation guide, preserving existing runtime versions/defaults and separating project initialization.
+- Retained explicit Curate Memory and selected Local → Versioned actions in both interfaces, with fresh current previews isolated from unavailable historical reviews and unchanged approval guards.
+- Close always returns a confirmed, visible final receipt, including zero observations, replay, deferred saving and diagnostic failures.
+- Removed the old routine memory moderation queues, cards and attention prompts from text/visual interfaces; CLI status keeps maintenance diagnostics in explicit JSON rather than nagging counters.
+- Bounded current-session agent reconciliation reuses semantic validation and transactional history for eligible Local knowledge. Protected, ambiguous and unsupported changes preserve originals; no new external provider is required.
+- MCP chat text now uses native Markdown: a small ›_ prodero launch mark, factual project overview, named actions and brief unbranded task/save updates. Terminal CLI/explicit ASCII fallback and visual App contracts remain separate.
+
+Project schema remains **8** and knowledge schema remains **3**; no canonical schema migration is added. See [compatibility and verification](docs/COMPATIBILITY.md) for the tested artifact and host coverage.
+
 ## 0.2.1 — 2026-10-25 (Public Preview)
 
 - Corrected public documentation and release wording, including installation and compatibility guidance.

package/README.md

@@ -2,16 +2,30 @@
 
 **Project memory for Codex and Claude Code.**
 
+**0.3.0 Public Preview.** See [compatibility and verification](docs/COMPATIBILITY.md) for the exact coverage and limitations.
+
 Keep project decisions, conventions, and lessons across sessions, right inside your coding assistant.
 
-**Install in two commands → open Codex or Claude Code → type prodero.**
+## Install with a prompt
+
+Paste this into your coding agent:
+
+```text
+Install Prodero Curator using https://prodero.io/curator/setup.md
+```
+
+The guide covers Codex and experimental Claude Code: it inspects your setup, proposes one concrete plan and verifies the selected client's connection. See the [publication handoff](docs/INSTALL-WITH-AGENT.md). [Manual installation](#manual-installation) remains available.
+
+## Manual installation
+
+Install the latest published release in two commands, reopen your coding client, then type **`prodero`**. The prompt-assisted guide resolves `@latest` to an exact reviewed version before installing.
 
 ```sh
-npm install --global @prodero/curator@0.2.1
+npm install --global @prodero/curator@latest
 prodero install
 ```
 
-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).
+Requires **Node.js >=22.14.0 <23**, npm and Git. **v0.3.0 Public Preview.** Claude Code remains experimental; native-client coverage is recorded by version below. See the [compatibility matrix](docs/COMPATIBILITY.md).
 
 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.
@@ -19,6 +33,44 @@ Requires **Node.js >=22.14.0 <23**, npm and Git. **v0.2.1 Public Preview.** Code
 
 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).
 
+## How Curator helps
+
+### Project memory, selected for the task
+
+One Context Engine selects bounded context from Local and Versioned Knowledge and active skills. Your agent gets the relevant project background instead of the whole memory store.
+
+```mermaid
+flowchart LR
+    local["Local Knowledge<br/>Git-ignored"] --> engine["Curator<br/>Context Engine"]
+    versioned["Versioned Knowledge<br/>Git-shareable"] --> engine
+    skills["Active skills<br/>Reusable procedures"] --> engine
+    engine --> agent["Your coding agent<br/>Required + Relevant + Skills"]
+    classDef store fill:#F0F5FF,stroke:#7897C2,color:#152B46
+    classDef focus fill:#DFF4D7,stroke:#669D50,color:#203D17
+    classDef output fill:#F4EBFF,stroke:#A17AC4,color:#38214F
+    class local,versioned,skills store
+    class engine focus
+    class agent output
+```
+
+Local Knowledge stays Git-ignored; Versioned Knowledge can travel with reviewed Git changes. Curator retrieves both and does not commit or push.
+
+### Recorded lessons can help the next task
+
+When your agent records useful outcomes and closes the session with synchronization, Curator can bring the resulting Local Knowledge into later tasks.
+
+```mermaid
+flowchart LR
+    work["Work with context"] --> close["Close the session<br/>Sync to Local Knowledge"]
+    close --> next["Next task<br/>Reuse relevant lessons"]
+    classDef step fill:#F0F5FF,stroke:#7897C2,color:#152B46
+    classDef saved fill:#DFF4D7,stroke:#669D50,color:#203D17
+    class work,next step
+    class close saved
+```
+
+This follows the agent's Prepare → Record → Close workflow; Curator does not watch every conversation or save unrecorded details.
+
 ![Curator App overview with Curate Memory](docs/images/prodero-overview-cropped.png)
 
 *Current Curator App with demonstration project data.*
@@ -46,9 +98,11 @@ Everyday work happens in conversation with Codex or Claude Code; the terminal is
 - “Update the saved testing convention to use the new fixture directory.”
 - “Review which Local lessons would be useful to share with the team.”
 
-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.
+Use **Knowledge** to search, inspect and edit saved items. Explicit Open also offers **Curate Memory** and **Local → Versioned**: preview current knowledge, select exact changes or records, and approve before applying. Curator handles ordinary memory maintenance during work; there is no memory moderation dashboard or routine review queue. Bounded conflicts can be analyzed by the current session's coding agent. Deterministic checks preserve original evidence and protected rules when a safe change cannot be established. Only a decision that actually blocks the current task needs the user's input.
+
+The [maintenance contract](docs/V0.3.0-MAINTENANCE.md) describes automatic work, conservative retention and the remaining safety boundaries.
 
-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.
+Where the host supports MCP Apps, Curator provides a graphical interface. Otherwise, use text mode: **“Show Prodero as text.”** In 0.3.0, chat uses compact native Markdown with a small `›_ prodero` launch mark and brief task/save updates. The terminal keeps its own renderer. See [text behavior and examples](docs/V0.3.0-CHAT-TEXT.md). You do not need to memorize CLI commands.
 
 ## Main capabilities
 
@@ -70,7 +124,7 @@ The generated `.prodero/index.md` can include active **Local skill titles and pa
 
 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).
+MCP Apps, workspace roots and sampling support vary by host. Text mode supports core workflows; explicit edits, sharing and Required-policy decisions retain their safety checks. Legacy maintenance APIs remain technical compatibility interfaces. See the [host/runtime matrix](docs/COMPATIBILITY.md) and [setup guide](docs/hosts.md).
 
 ## Privacy and security
 

package/dist/chat-text.js

@@ -0,0 +1,139 @@
+import { numberedActions, chatOpenActions } from './conversation-presentation.js';
+import { safeText, textFence } from './text-layout.js';
+// Project names, titles and diagnostics are data, never Markdown structure or links.
+export const markdownText = (value) => safeText(value).replace(/[\r\n\u2028\u2029]+/g, ' ').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/[\\`*{}\[\]()#!|~]/g, '\\$&').replace(/(?<![\p{L}\p{N}])_|_(?![\p{L}\p{N}])/gu, '\\$&');
+const count = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+const plural = (value, noun) => `${value.toLocaleString('en-US')} ${noun}${value === 1 ? '' : 's'}`;
+const hardBreak = '\\' + '\n';
+export function renderChatText(vm, diagnostics = false, expanded = diagnostics) {
+    const scene = vm.textScene, action = scene?.action, v = vm.conversation;
+    const full = expanded || !v || v.kind === 'details';
+    const parts = [];
+    const text = (value) => { if (value !== undefined && value !== null && String(value).trim())
+        parts.push(markdownText(value)); };
+    const heading = (value) => parts.push(`**${markdownText(value)}**`);
+    const attention = () => { for (const value of v?.attention ?? [])
+        text(value); };
+    const bodies = (title, items) => {
+        if (!items.length)
+            return;
+        parts.push(`### ${markdownText(title)}`);
+        for (const item of items) {
+            heading(item.title);
+            // Exact requested evidence/code is literal. These fences contain source
+            // material only, never the interface, navigation or a manufactured screen.
+            if (item.body)
+                parts.push(textFence(item.body));
+            if (item.notes.length)
+                parts.push(item.notes.map(note => `- ${markdownText(note)}`).join('\n'));
+        }
+    };
+    const actions = () => {
+        const available = numberedActions(vm, full);
+        if (!available.length)
+            return;
+        parts.push('You can ask me to:\n\n' + available.map(a => `- ${markdownText(a.label)}${a.approval ? ' — Explicit approval required.' : ''}`).join('\n'));
+    };
+    if (scene?.home && !full) {
+        // The small mark belongs to an explicit launch/overview, not every work step.
+        parts.push('**›_ prodero**' + (scene.project ? ` · **${markdownText(scene.project)}**` : ''));
+        const h = scene.home;
+        if (h.initialized === true) {
+            if (action === 'initialized')
+                text('Project memory initialized.');
+            const memory = count(h.records) ? plural(h.records, 'record') : 'not loaded';
+            const local = count(h.local) ? h.local.toLocaleString('en-US') : 'not loaded';
+            const versioned = count(h.versioned) ? h.versioned.toLocaleString('en-US') : 'not loaded';
+            const context = count(h.loadedInstructions) ? `Context loaded: ${plural(h.loadedInstructions, 'instruction')}` : 'Loaded instruction count: unavailable';
+            parts.push([`├─ Memory: ${memory}`, `├─ Local: ${local} · Versioned: ${versioned}`, `└─ ${context}`].join(hardBreak));
+            attention();
+            const menu = chatOpenActions(vm);
+            if (menu.length) {
+                parts.push(menu.map(a => `**${a.number}.** ${markdownText(a.label)}`).join(hardBreak));
+                text('Choose a number or ask in your own words.');
+            }
+            const updates = vm.notices.filter(notice => notice.startsWith('Update available:'));
+            updates.forEach(text);
+            if (updates.length)
+                text('Ask me to show update instructions.');
+        }
+        else {
+            heading(h.initialized === false ? 'Not initialized' : 'Project state unavailable');
+            (v?.facts ?? vm.notices).forEach(text);
+            attention();
+            if (v?.prompt)
+                text(v.prompt);
+        }
+    }
+    else if (action === 'prepare' || action === 'context') {
+        heading(v?.blocking ? v.state : action === 'context' ? 'View Context' : v?.attention.length ? 'Context prepared' : 'Context Ready');
+        const loaded = v?.contextLoaded;
+        if (loaded && [loaded.instructions, loaded.knowledge, loaded.skills].every(count)) {
+            text(`Loaded ${plural(loaded.instructions, 'project instruction')} · ${plural(loaded.knowledge, 'knowledge record')} · ${plural(loaded.skills, 'skill')}.`);
+        }
+        else
+            text('Loaded context counts unavailable.');
+        if (v?.blocking || v?.attention.length)
+            attention();
+        else
+            text(action === 'context' ? 'Read-only context view.' : 'Continuing the task.');
+        if (v?.prompt)
+            text(v.prompt);
+        if (full) {
+            if (scene?.task)
+                text(`Task: ${scene.task}`);
+            if (scene?.budget && Number.isFinite(scene.budget.used) && Number.isFinite(scene.budget.total))
+                text(`${scene.budget.used.toLocaleString('en-US')} / ${scene.budget.total.toLocaleString('en-US')} est. Prodero tokens`);
+            vm.sections.forEach(s => bodies(s.title, s.items));
+            actions();
+        }
+    }
+    else if (action === 'session-close') {
+        const receipt = v?.closeReceipt;
+        if (receipt)
+            parts.push(`**${markdownText(receipt.label)}** · ${markdownText(receipt.detail)}`);
+        else
+            text('Session status unavailable.');
+        attention();
+        if (full) {
+            if (vm.metrics.length)
+                parts.push(vm.metrics.map(m => `- ${markdownText(m.label)}: ${markdownText(m.value)}`).join('\n'));
+            vm.sections.forEach(s => bodies(s.title, s.items));
+            actions();
+        }
+    }
+    else if (vm.knowledgeTable) {
+        heading('Knowledge');
+        const table = vm.knowledgeTable;
+        text(table.rows.length ? `Showing ${table.offset + 1}–${table.offset + table.rows.length} of ${table.total}. Ask for a record by title.` : 'No knowledge matches these filters.');
+        // Long titles and mobile clients benefit from lists, rather than a wide table.
+        if (!expanded)
+            parts.push(table.rows.map(row => `- **${markdownText(row.title)}** — ${markdownText(row.layer)} · ${markdownText(row.category)}`).join('\n'));
+        else
+            vm.sections.forEach(s => bodies(s.title, s.items));
+        actions();
+    }
+    else {
+        heading(vm.title.replace(/^Prodero · /, ''));
+        if (!full && v) {
+            if (v.state && v.state !== 'Ready')
+                text(v.state);
+            v.facts.forEach(text);
+            attention();
+        }
+        else {
+            if (vm.metrics.length)
+                parts.push(vm.metrics.map(m => `- ${markdownText(m.label)}: ${markdownText(m.value)}${m.detail ? ` · ${markdownText(m.detail)}` : ''}`).join('\n'));
+            vm.notices.forEach(text);
+            vm.sections.forEach(s => bodies(s.title, s.items));
+        }
+        if (v?.prompt)
+            text(v.prompt);
+        actions();
+    }
+    if (diagnostics || full && action === 'migration')
+        for (const section of vm.diagnostics ?? [])
+            bodies(section.title, section.items);
+    return parts.filter(Boolean).join('\n\n');
+}
+//# sourceMappingURL=chat-text.js.map

package/dist/cli.js

@@ -3,10 +3,11 @@ import { realpathSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 import { captureLocalStdioContext } from "./mcp-workspace.js";
 import { planProjectMigration, applyProjectMigration } from "./core/migrations.js";
-import { buildViewModel, renderText } from "./presentation.js";
+import { buildViewModel, renderTerminalText as renderText } from "./presentation.js";
 import { runMemorySync } from './core/memory-sync.js';
 import { machineIntegrations } from "./hosts/manager.js";
 import { installWizard } from "./hosts/wizard.js";
+import { installCommand } from "./hosts/install-command.js";
 import { runtimeCommand } from "./hosts/runtime-command.js";
 import { buildMemoryTransformationBundle } from "./core/memory-transformation-bundle.js";
 import { getMemoryIntelligencePlan } from "./core/memory-intelligence.js";
@@ -25,13 +26,15 @@ Usage: prodero <command> [--root /absolute/project]
   migrate [status]        Review or apply the project knowledge update with backup
   init                    Initialize the selected project
   install                 Open the interactive agent installation wizard
+  install --host HOST --dry-run [--json] Preview one host integration without writes
+  install --host HOST --yes [--json] Apply the reviewed integration for one host
   runtime <mode> --host HOST Switch one agent between package and dev (runtime --help)
   uninstall [host] [--all] Remove managed host integration; preserve projects
   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 Curate Memory (JSON; continue through MCP)
+  sync                    Legacy technical memory-workflow API (JSON)
   sync-sessions           Low-level deterministic closed-session recovery
   recall <query>          Recall project knowledge without a session
   context [query]         Inspect retrieved context
@@ -118,6 +121,10 @@ function parse(argv) {
     return { dev, checkout, json, command: helpRequested ? "help" : command, root, query, host: all ? "all" : host };
 }
 async function run(localStdio) {
+    if (process.argv[2] === 'install' && process.argv.length > 3) {
+        process.exitCode = await installCommand(process.argv.slice(3));
+        return;
+    }
     if (process.argv[2] === 'update') {
         process.exitCode = await updateCommand(process.argv.slice(3));
         return;

package/dist/contracts.js

@@ -34,6 +34,8 @@ export const PRODERO_TOOLS = {
     promotionPreview: "prodero_promotion_preview",
     promote: "prodero_promote",
     sessionRecord: "prodero_session_record",
+    sessionReconcilePrepare: "prodero_session_reconcile_prepare",
+    sessionReconcilePropose: "prodero_session_reconcile_propose",
     sessionClose: "prodero_session_close",
     sessionReview: "prodero_session_review",
     sessionReviewMutate: "prodero_session_review_mutate",