@prodero/curator 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+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 { runMemorySync } from './core/memory-sync.js';
+import { machineIntegrations } from "./hosts/manager.js";
+import { installWizard } from "./hosts/wizard.js";
+import { runtimeCommand } from "./hosts/runtime-command.js";
+import { buildMemoryTransformationBundle } from "./core/memory-transformation-bundle.js";
+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 { cliProjectRoot, explicitProjectRoot } from "./core/project-root.js";
+import { checkForUpdate, installLatest } from "./core/update.js";
+const help = `Prodero ${PRODERO_VERSION}
+
+Usage: prodero <command> [--root /absolute/project]
+  mcp, --stdio            Start MCP in the host workspace; --dev loads the saved development runtime
+  migrate [status]        Review or apply the project knowledge update with backup
+  init                    Initialize the selected 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
+  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-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)
+  help, --help            Show this help
+  --version               Show the installed version
+
+--root accepts an absolute existing directory, as --root PATH or --root=PATH.
+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;
+    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];
+        if (arg === "--help" || arg === "-h") {
+            helpRequested = true;
+            continue;
+        }
+        if (arg === "--dev") {
+            if (dev)
+                throw new Error("Specify --dev only once.");
+            dev = true;
+            continue;
+        }
+        if (arg === "--checkout") {
+            if (checkout !== undefined)
+                throw new Error("Specify --checkout only once.");
+            checkout = argv[++i];
+            if (!checkout || checkout.startsWith("--"))
+                throw new Error("--checkout requires a directory.");
+            continue;
+        }
+        if (arg === "--all") {
+            if (all)
+                throw new Error("Specify --all only once.");
+            all = true;
+            continue;
+        }
+        if (arg === "--root" || arg.startsWith("--root=")) {
+            if (root !== undefined)
+                throw new Error("Specify --root only once.");
+            root = arg === "--root" ? argv[++i] : arg.slice(7);
+            if (!root || root.startsWith("--"))
+                throw new Error("--root requires an absolute project directory.");
+        }
+        else if (!command && commands.has(arg))
+            command = arg;
+        else if (arg.startsWith("-"))
+            throw new Error("Unknown flag. Run prodero --help.");
+        else if (!command)
+            throw new Error("Unknown command. Run prodero --help.");
+        else if (command === "install")
+            throw new Error("Run prodero install without arguments; choose an agent in the interactive wizard.");
+        else if (command === "uninstall" && host === undefined)
+            host = arg;
+        else if (["migrate", "prepare", "context", "recall", "memory-bundle"].includes(command) && query === undefined)
+            query = arg;
+        else
+            throw new Error("Unexpected argument. Run prodero --help.");
+    }
+    command ??= "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))
+        throw new Error("Use --all only with uninstall and without a host name.");
+    if (root !== undefined && ["install", "uninstall", "help", "--version", "check-update", "update"].includes(command))
+        throw new Error(`--root is not used by ${command}.`);
+    if ((dev || checkout !== undefined) && !["mcp", "--stdio"].includes(command))
+        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 };
+}
+async function run(localStdio) {
+    if (process.argv[2] === 'runtime') {
+        await runtimeCommand(process.argv.slice(3));
+        return;
+    }
+    const { command, root, query, host, dev, checkout } = parse(process.argv.slice(2));
+    if (command === "help") {
+        console.log(help);
+        return;
+    }
+    if (command === "--version") {
+        console.log(PRODERO_VERSION);
+        return;
+    }
+    if (command === "install") {
+        process.exitCode = await installWizard();
+        return;
+    }
+    if (command === "uninstall" || (command === "status" && root === undefined)) {
+        const result = await machineIntegrations(command === "status" ? "status" : command, host);
+        console.log(JSON.stringify(result, null, 2));
+        if (!result.ok)
+            process.exitCode = 1;
+        return;
+    }
+    if (command === "mcp" || command === "--stdio")
+        localStdio ??= captureLocalStdioContext();
+    const rootArg = command === "mcp" || command === "--stdio" ? (root === undefined ? undefined : await explicitProjectRoot(root)) : ["update", "check-update"].includes(command) ? undefined : await cliProjectRoot(root);
+    if (command === "--stdio" || command === "mcp") {
+        if (dev) {
+            const { startDevelopmentRuntime } = await import('./mcp-development.js');
+            await startDevelopmentRuntime(localStdio, { projectRoot: rootArg, checkout });
+            return;
+        }
+        const server = createServer({ projectRoot: rootArg, localStdio });
+        await server.connect(new StdioServerTransport());
+        return;
+    }
+    if (command === "migrate") {
+        if (query && query !== "status")
+            throw new Error("Use prodero migrate or prodero migrate status.");
+        let plan = await planProjectMigration(rootArg);
+        if (query !== "status" && (plan.safeToApply || plan.state === "recovery-required")) {
+            const result = await applyProjectMigration(rootArg, { approved: true, planId: plan.planId, recover: plan.state === "recovery-required" });
+            plan = result.plan;
+        }
+        console.log(renderText(buildViewModel({ action: "migration", root: rootArg, plan }), true));
+        if (plan.blocked)
+            process.exitCode = 1;
+        return;
+    }
+    if (command === "init") {
+        console.log(JSON.stringify(await initializeProject(rootArg), null, 2));
+        return;
+    }
+    if (["status", "prepare"].includes(command)) {
+        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));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    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));
+        return;
+    }
+    if (command === "memory-bundle") {
+        if (!query)
+            throw new Error("memory-bundle requires one planner candidate ID");
+        console.log(JSON.stringify(await buildMemoryTransformationBundle(rootArg, query)));
+        return;
+    }
+    if (command === "memory-plan") {
+        console.log(JSON.stringify(await getMemoryIntelligencePlan(rootArg), null, 2));
+        return;
+    }
+    if (command === "sync") {
+        console.log(JSON.stringify(await runMemorySync(rootArg, { action: "start" }), null, 2));
+        return;
+    }
+    if (command === "sync-sessions") {
+        console.log(JSON.stringify(await syncProject(rootArg, { onlyClosed: true }), null, 2));
+        return;
+    }
+    if (command === "recall") {
+        console.log(JSON.stringify(await recallProject(rootArg, query ?? ""), null, 2));
+        return;
+    }
+    if (command === "context") {
+        console.log(JSON.stringify(await resolveProjectContext(rootArg, query), null, 2));
+        return;
+    }
+    if (command === "prepare") {
+        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;
+    }
+}
+export async function main(localStdio) {
+    await run(localStdio).catch((error) => {
+        console.error(`[prodero] ${publicDiagnostic(error)}`);
+        process.exitCode = 1;
+    });
+}
+// Compatibility for direct CLI execution; importing from the public binary never auto-starts.
+if (process.argv[1] && pathToFileURL(realpathSync(process.argv[1])).href === import.meta.url)
+    await main();
+//# sourceMappingURL=cli.js.map

package/dist/context-instructions.js

@@ -0,0 +1,2 @@
+export const CONTEXT_ROUTING = 'Before answering questions that may depend on project history, previous decisions, implementation details, or project-specific knowledge, call prodero_recall. Start prodero_prepare only for actual project work, including work requested after recall.';
+//# sourceMappingURL=context-instructions.js.map

package/dist/contracts.js

@@ -0,0 +1,50 @@
+export const PRODERO_RESOURCE_URI = "ui://prodero/status.html";
+export const PRODERO_LIFECYCLE_RESOURCE_URI = "ui://prodero/lifecycle.html";
+export const PRODERO_TOOLS = {
+    instructionsRead: "prodero_instructions_read",
+    uiCardState: "prodero_ui_card_state",
+    configGet: "prodero_config_get",
+    configSet: "prodero_config_set",
+    text: "prodero_text",
+    plugins: "prodero_plugins",
+    pluginAction: "prodero_plugin_action",
+    open: "prodero_open",
+    status: "prodero_status",
+    statusDetails: "prodero_status_details",
+    initialize: "prodero_initialize",
+    migrate: "prodero_migrate",
+    curation: "prodero_curation",
+    curationReview: "prodero_curation_review",
+    curationReasoningPrepare: "prodero_curation_reasoning_prepare",
+    curationReasoningPropose: "prodero_curation_reasoning_propose",
+    curationApply: "prodero_curation_apply",
+    prepare: "prodero_prepare",
+    context: "prodero_context",
+    recall: "prodero_recall",
+    memoryTransformPrepare: "prodero_memory_transform_prepare",
+    memoryTransformPropose: "prodero_memory_transform_propose",
+    instructionReview: "prodero_instruction_review",
+    instructionOptimize: "prodero_instruction_optimize",
+    knowledge: "prodero_knowledge",
+    knowledgeMutate: "prodero_knowledge_mutate",
+    memorySearch: "prodero_memory_search",
+    remember: "prodero_remember",
+    forget: "prodero_forget",
+    promotionPreview: "prodero_promotion_preview",
+    promote: "prodero_promote",
+    sessionRecord: "prodero_session_record",
+    sessionClose: "prodero_session_close",
+    sessionReview: "prodero_session_review",
+    sessionReviewMutate: "prodero_session_review_mutate",
+    sync: "prodero_sync",
+    memorySync: "prodero_memory_sync",
+    skillCreate: "prodero_skill_create",
+    skills: "prodero_skills",
+    skillsRead: "prodero_skills_read",
+    skillPreview: "prodero_skill_preview",
+    skillReview: "prodero_skill_review",
+    checkUpdate: "prodero_check_update",
+    update: "prodero_update",
+};
+export const PRODERO_TOOL_NAMES = Object.values(PRODERO_TOOLS);
+//# sourceMappingURL=contracts.js.map

package/dist/conversation-presentation.js

@@ -0,0 +1,262 @@
+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.';
+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) {
+    const r = payload.result ?? payload;
+    const root = r.root ?? r.projectRoot ?? r.project?.root ?? payload.project?.root ?? payload.root;
+    const call = (label, tool, args = {}) => ({ label, tool, arguments: { ...(root ? { projectRoot: root } : {}), ...args } });
+    const v = { kind: 'summary', title: vm.title, state: 'Ready', facts: [], attention: [], blocking: false, reviewRequired: false };
+    const next = (prompt, action) => { v.prompt = prompt; v.continuation = action; };
+    if (['open', 'status', 'status-details', 'initialized'].includes(payload.action)) {
+        const p = payload.project;
+        v.title = `Prodero · ${p?.name ?? 'Project'}`;
+        if (typeof p?.initialized !== 'boolean') {
+            v.state = 'Project state unavailable';
+            v.attention.push('Check project details before continuing.');
+        }
+        else if (!p.initialized) {
+            v.state = 'Not initialized';
+            next('Initialize Prodero for this project?', call('Initialize Prodero', 'prodero_initialize'));
+            v.facts.push('Creates project memory and managed agent instructions.');
+        }
+        else {
+            v.state = payload.action === 'initialized' ? 'Initialized' : 'Ready';
+            if (p.knowledgeCount !== undefined)
+                v.facts.push(`Memory  ${p.knowledgeCount}`);
+            if (p.skillCount !== undefined)
+                v.facts.push(`Skills  ${p.skillCount}`);
+            if (p.activeSessionCount !== undefined)
+                v.facts.push(`Session  ${p.activeSessionCount ? `active (${p.activeSessionCount})` : 'none active'}`);
+            if (payload.phase === 'initial')
+                v.facts.push('Lightweight status; counts not loaded.');
+            if (p.conflictCount)
+                v.attention.push(`Conflicts to review: ${p.conflictCount}.`);
+            const areas = p.memoryOverview?.areas ?? [];
+            if (areas.length) {
+                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'));
+            }
+            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 }));
+            }
+            const c = payload.curation;
+            if (c?.state === 'unavailable')
+                v.attention.push('Saved review unavailable. Open details before continuing.');
+            if (c?.prominent) {
+                const q = c.projection;
+                if (q?.needsInputNow)
+                    v.attention.push(`Items needing your input: ${q.needsInputNow}.`);
+                if (q?.readyChangeGroups)
+                    v.attention.push(`${n(q.readyChangeGroups, 'proposed change')} ready for review.`);
+                if (q?.blockedGroups)
+                    v.attention.push(`${n(q.blockedGroups, 'change')} blocked.`);
+                next('Review these items?', call('Review saved decisions', 'prodero_curation', { action: 'plan', details: true }));
+            }
+            else if (p.conflictCount)
+                next('Inspect knowledge and its review signals?', call('Inspect knowledge', 'prodero_knowledge'));
+            if (payload.bootstrap?.warnings?.length)
+                v.attention.push(...payload.bootstrap.warnings);
+            if (payload.update?.available)
+                v.attention.push(`Update available: ${payload.update.latest}.`);
+            if (!v.attention.length && payload.phase !== 'initial')
+                v.facts.push('No attention needed.');
+            if (payload.action === 'open' || payload.action === 'initialized') {
+                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')];
+            }
+        }
+        v.details = call('Show project details', 'prodero_status_details', { details: true });
+        if (payload.action === 'status-details')
+            v.kind = 'details';
+    }
+    else if (payload.action === 'prepare' || payload.action === 'context') {
+        const c = payload.action === 'context' ? r : r.context, m = c.metrics, readiness = c.policyReadiness;
+        v.title = 'Prodero · Context Ready';
+        const omitted = m.requiredGlobalExcludedItems ?? c.selection?.omittedRequired?.length ?? 0;
+        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}`);
+        if (r.session)
+            v.facts.push('Session  active');
+        if (omitted)
+            v.attention.push(`${n(omitted, 'required instruction')} not loaded. Do not continue work.`);
+        if (readiness?.state === 'context-needed')
+            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}`));
+        if (readiness?.state === 'context-needed')
+            next('Specify the work paths or task scope, then prepare again.');
+        else if (omitted)
+            next('Review the missing instructions?', c.snapshot?.reviewId ? call('Review required context', 'prodero_instruction_review', { reviewId: c.snapshot.reviewId }) : undefined);
+        else if (v.blocking)
+            next('Inspect the required context and conflicts?');
+        if (payload.action === 'context')
+            v.kind = 'details';
+        v.detailSource = 'context';
+    }
+    else if (payload.action === 'session-close') {
+        v.title = 'Prodero · Session closed';
+        v.state = r.alreadyClosed ? 'Already closed' : r.learned.syncState === 'pending-auto-sync' ? 'Saving deferred' : 'Saved';
+        v.facts.push(`${n(r.learned.observations, 'observation')} recorded`);
+        if (r.learned.syncState === 'pending-auto-sync')
+            v.attention.push('Saving deferred; it will resume before the next work session.');
+        if (r.review?.needsReview)
+            v.attention.push(`Items needing review: ${r.review.needsReview}.`);
+        if (r.review?.error)
+            v.attention.push('Knowledge review unavailable.');
+        if (v.attention.length)
+            next('Review session knowledge?', call('Review session', 'prodero_session_review', { sessionId: r.session.id }));
+        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.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';
+        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'));
+        }
+        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'));
+        }
+        else if (r.state === 'awaiting_review') {
+            v.reviewRequired = true;
+            v.attention.push(r.review?.kind === 'promotion' ? 'Nothing published. Review the proposed wording before approval.' : 'No approval given. Review the proposed changes first.');
+            next('Review the proposed changes?', inspect);
+        }
+        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 }));
+        }
+        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.');
+            next('Show the question and review details?', inspect);
+        }
+        else if (r.state === 'stale') {
+            v.attention.push('Re-analyze before continuing; earlier review is out of date.');
+            next('Re-analyze memory?', vm.actions.find(a => a.label === 'Re-analyze memory'));
+        }
+        else if (r.state === 'completed') {
+            if (s.areasProcessed)
+                v.facts.push(`${s.sourcesBefore} → ${s.currentAfter} memories`, `${s.archived} previous memories preserved in history`);
+            else if (!s.promoted && !s.brokenLinksFixed)
+                v.facts.push('No memory changes.');
+            if (s.brokenLinksFixed)
+                v.facts.push(`${n(s.brokenLinksFixed, 'broken link')} fixed`);
+            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`);
+            if (s.unresolved)
+                v.attention.push(`${n(s.unresolved, 'memory', 'memories')} 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 (v.attention.length)
+                next('Review the remaining items?', inspect);
+        }
+        if (r.error)
+            v.attention.push('This step could not finish. Check saved progress before retrying.');
+    }
+    else if (payload.action === 'migration') {
+        const p = payload.plan;
+        v.title = 'Prodero · Project update';
+        v.state = vm.title;
+        v.blocking = p.state !== 'current';
+        v.reviewRequired = Boolean(p.safeToApply || ['review-required', 'recovery-required'].includes(p.state));
+        v.attention = vm.notices;
+        if (p.safeToApply)
+            next('Review the update before applying?', call('Review project update', 'prodero_migrate', { action: 'status', ...(payload.resume ? { resume: payload.resume } : {}), details: true }));
+        else if (p.state === 'current')
+            next('Continue.', vm.actions.find(a => a.label === 'Continue'));
+        else if (p.state === 'recovery-required')
+            next('Review recovery instructions?', call('Review recovery', 'prodero_migrate', { action: 'status', details: true }));
+        v.details = call('Show update details', 'prodero_migrate', { action: 'status', details: true });
+    }
+    else if (payload.action === 'promotion-applied') {
+        v.title = 'Prodero · Published';
+        v.state = 'Complete';
+        v.facts.push(`${n(r.published, 'memory', 'memories')} shared`);
+        if (r.conflicts?.length) {
+            v.attention.push(`Conflicts remaining local: ${r.conflicts.length}.`);
+            next('Inspect the remaining knowledge?', call('Inspect knowledge', 'prodero_knowledge'));
+        }
+    }
+    else {
+        // Explicit inspection/review surfaces retain full content and diagnostics.
+        v.kind = 'details';
+        v.reviewRequired = ['promotion-preview', 'instruction-optimize', 'curation'].includes(payload.action);
+        if (payload.action === 'curation')
+            v.blocking = Boolean(payload.projection?.blockedGroups);
+    }
+    v.attention = [...new Set(v.attention)];
+    if (v.kind === 'summary' && (v.attention.length || v.blocking || v.reviewRequired))
+        v.kind = 'attention';
+    return v;
+}
+export function conversationMenu(v) {
+    return v.suggestions?.length ? v.suggestions : v.continuation ? [v.continuation] : [];
+}
+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 }));
+}
+export function renderActionMenu(actions, start = 1) {
+    if (!actions.length)
+        return '';
+    return 'Available actions:\n\n' + actions.map((a, index) => `${index + start}. ${a.label}${a.approval ? ' (workflow approval required)' : ''}`).join('\n') + '\n\nReply with a number or the command name.';
+}
+export function renderConversation(v) {
+    const menu = renderActionMenu(conversationMenu(v));
+    return [v.title, `${v.blocking || v.reviewRequired ? '⚠' : '✓'} ${v.state}`, ...v.facts, ...v.attention.map(s => `⚠ ${s}`), menu ? `\n${menu}\n` : undefined, v.prompt].filter(Boolean).join('\n');
+}
+/** 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;
+    return {
+        kind: diagnostics ? 'diagnostic' : details ? 'details' : v.kind,
+        succeeded: payload.ok !== false,
+        blocking: v.blocking,
+        contextComplete: v.contextComplete,
+        reviewRequired: v.reviewRequired,
+        continuation: details && ((payload.action === "memory-sync" && r.state === "awaiting_review") || (payload.action === "migration" && vm.actions.some(a => a.approval))) ? vm.actions.find(a => a.approval) : v.continuation,
+        details: v.details,
+        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 } })) } : {}),
+        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.',
+        ...(payload.bootstrap ? { bootstrap: payload.bootstrap } : {}),
+        ...(payload.action === 'context' ? { context: r } : {}),
+        ...(payload.action === 'prepare' ? { session: r.session, context: r.context, automaticSync: r.automaticSync } : {}),
+        ...(payload.action === 'memory-sync' ? { workflow: { id: r.id, revision: r.revision, state: r.state, next: r.next, semantic: r.semantic, curation: r.curation, clarification: r.clarification, jobs: r.jobs, error: r.error, coverage: r.coverage, review: r.review, promotionCandidates: r.promotionCandidates } } : {}),
+    };
+}
+//# sourceMappingURL=conversation-presentation.js.map

package/dist/core/agent-instructions.js

@@ -0,0 +1,39 @@
+import { SKILL_EXECUTION_ROUTING } from "../skill-instructions.js";
+import { CONTEXT_ROUTING } from "../context-instructions.js";
+import { SETTINGS_ROUTING } from "../settings-definition.js";
+import { PRESENTATION_LAUNCHER, PRESENTATION_ROUTING } from "../presentation.js";
+export const AGENT_INSTRUCTIONS = `## Prodero Project Intelligence
+
+Apply these instructions to the current user workspace. The directory containing this document is the Prodero installation, not the project root.
+
+This project uses Prodero for persistent project knowledge, session memory, and reusable project skills.
+
+## Prodero UI
+
+${PRESENTATION_LAUNCHER} The selected operation opens Project Intelligence and loads Bootstrap Context.
+
+\`open prodero\` and \`show prodero\` have the same meaning. Use \`prodero_status\` only for a lightweight read-only status check. Do not inspect repository files first, open README.md, explain Prodero, or search documentation as a substitute for opening the interface.
+
+${SETTINGS_ROUTING}
+
+${PRESENTATION_ROUTING}
+
+${CONTEXT_ROUTING}
+
+Before substantial work:
+1. Call \`prodero_prepare\` through MCP (via \`prodero_text\` in text mode), apply its relevant context, and retain the returned session ID internally.
+2. If MCP is unavailable, use the Prodero CLI; access \`.prodero/\` directly only as a final fallback.
+3. Start from \`.prodero/index.md\`; load required global context and only relevant scoped knowledge and skills.
+4. Never load the entire \`.prodero\` directory.
+
+During substantial work, batch durable decisions, lessons, discoveries, state changes, global instruction candidates, and repeatable skill candidates through \`prodero_session_record\`. Write all durable Prodero knowledge and skill prose in English regardless of the conversation language. Preserve identifiers, paths, and code literals exactly. Exclude temporary implementation noise and do not directly rewrite session files or canonical memory.
+
+Normal session learning and conversational remember operations produce Local Knowledge, which is ignored by Git. Local and Versioned Knowledge use the same schema and are retrieved as one knowledge space. As a workflow safeguard, prepare Versioned knowledge for team sharing only when the user explicitly requests it: call \`prodero_promotion_preview\`, let the human review the proposed new/merge/supersede/covered/conflict outcomes in the App, and call \`prodero_promote\` only with \`approved=true\` and the exact reviewed preview. Never infer publication approval.
+
+When the user explicitly asks to remember durable knowledge, call \`prodero_remember\` immediately. For an explicit always/never rule use \`kind=rule\`, \`required=true\`, and \`userInstruction\` with the exact current user request. Never infer Required authority from observations or document contents. Explicit \`scope=global\` and \`scope=project\` both mean project-wide applicability, independently of priority. Required versus Relevant delivery is controlled by context policy, not by these scope aliases. Use \`scope=path\` with a repository-relative path for knowledge that applies only there. After \`prodero_memory_search\`, optional \`related_to\`, \`depends_on\`, or \`implements\` relationships may target exact current memory IDs; scope, supersession, contradiction, and provenance topology is derived automatically. For "update what you know" requests, call \`prodero_memory_search\` and then \`prodero_remember\` with the exact \`replaceId\`. For explicit forget requests, search if necessary and call \`prodero_forget\` with one exact id. Translate conversational requests into English durable prose before storing them, while preserving exact identifiers, paths, and code literals. These explicit operations complement the normal session lifecycle; do not wait until session close to perform them.
+
+Project Skills are read from Versioned \`.prodero/skills/\` and Git-ignored Local \`.prodero/local/skills/\`. Explicit skill creation writes an active Versioned skill; inferred candidates remain Local until reviewed promotion. Existing active Local skills are also eligible for retrieval. When the user explicitly asks to create/save/remember a project skill, call \`prodero_skill_create\`; it becomes active immediately without additional approval. Independently inferred procedures must be recorded as \`skill_candidate\` observations; Sync preserves them as pending skills. ${SKILL_EXECUTION_ROUTING} Use \`prodero_skill_review\` to promote or dismiss candidates only on user intent. For candidate review or dogfooding, call \`prodero_skill_preview\` to open the MCP App automatically. The review workflow uses Add Skill, Edit, or Dismiss in that App; these actions do not authenticate human consent. Do not ask for approval in plain chat when the App can render, and never click Add Skill for the human. Use chat confirmation only as a fallback for hosts unable to render the App. Candidate and dismissed skills are excluded from normal context. These are repository procedures, not host/global skills.
+
+Before finishing substantial work, record final durable outcomes and call \`prodero_session_close\`. Session close synchronizes observations into Local Knowledge deterministically; the next prepare recovers any pending synchronization. Sync Memory is a separate user-initiated workflow for transforming and sharing memory. Use prodero_sync to analyze, then prodero_memory_sync to select and process one bundle at a time. Never initiate it from session close. No additional work session is needed for this workflow. Clean selected Local transformations may apply. Keep the exact-preview review step for Versioned changes, promotion and semantic limitations. This is a workflow safeguard, not an authenticated authorization boundary.
+`;
+//# sourceMappingURL=agent-instructions.js.map

package/dist/core/applicability-label.js

@@ -0,0 +1,11 @@
+export function applicabilityLabel(r) {
+    const a = r.applicability ?? { kind: 'legacy' };
+    if (a.kind === 'project')
+        return 'Throughout this project';
+    if (a.kind === 'unresolved')
+        return 'Work context not yet resolved';
+    if (a.kind === 'legacy')
+        return r.scope === 'global' ? 'Throughout this project' : r.scopeRef ?? 'Work context not yet resolved';
+    return [...(a.subsystems ?? []), ...(a.paths ?? []), ...(a.taskKinds ?? [])].join(' · ');
+}
+//# sourceMappingURL=applicability-label.js.map