@prodero/curator 0.2.0 → 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,8 +1,34 @@
 # Changelog
 
-## 0.2.0
+## 0.3.0 — 2026-11-09 (Public Preview)
 
-Release notes finalized 2026-10-23. This is the preparation date; registry publication is a separate maintainer action.
+- 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.
+- 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.
@@ -15,7 +41,7 @@ Release notes finalized 2026-10-23. This is the preparation date; registry publi
 - 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**. No canonical schema migration is added by this version bump. See [compatibility and evidence limits](docs/COMPATIBILITY.md) for exact-SHA CI, installed-artifact native checks and the owner-reported manual acceptance. The final release tree and artifact must satisfy the [release gates](docs/RELEASING.md); these notes do not announce registry availability.
+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)
 

package/README.md

@@ -2,18 +2,30 @@
 
 **Project memory for Codex and Claude Code.**
 
-> **0.2.0 release materials.** The npm command below requires 0.2.0 to be published. For review before publication, use the exact candidate tarball and isolated setup in [the release guide](docs/RELEASING.md). A checkout or local tarball does not establish registry availability. See [0.2.0 changes](CHANGELOG.md) and [verification limits](docs/COMPATIBILITY.md).
+**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.0
+npm install --global @prodero/curator@latest
 prodero install
 ```
 
-Requires **Node.js >=22.14.0 <23**, npm and Git. **v0.2.0 preview release.** Codex CLI has native text-workflow evidence; Claude Code remains experimental, with native text-workflow evidence. 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.
@@ -21,7 +33,47 @@ Requires **Node.js >=22.14.0 <23**, npm and Git. **v0.2.0 preview release.** Cod
 
 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).
 
-![Prodero Curator overview in the coding assistant](docs/images/prodero-overview-cropped.png)
+## 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.*
 
 ## Relevant context, automatically
 
@@ -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
 
@@ -68,9 +122,9 @@ The generated `.prodero/index.md` can include active **Local skill titles and pa
 
 ## Compatibility and limitations
 
-**Codex CLI 0.144.4 and Claude Code 2.1.302 passed native text workflows with the installed 0.2.0 runtime candidate.** Claude Code remains experimental. On 2026-10-23 the owner reported successful manual checks in Codex Desktop, Claude CLI and Codex Mobile. This is owner-reported acceptance; client build versions and an exact artifact/SHA binding were not supplied, so it is not independently traced per-case Apps certification. 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).
+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
 
@@ -91,4 +145,4 @@ 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. 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#commands-and-status).
+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/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",