@prodero/curator 0.0.0-stage → 0.2.0

package/dist/cli.js

@@ -0,0 +1,266 @@
+#!/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 { getProjectStatus, initializeProject, prepareProject, recallProject, PRODERO_VERSION, resolveProjectContext, syncProject, } from "./core/project.js";
+import { cliProjectRoot, explicitProjectRoot } from "./core/project-root.js";
+import { renderMachineStatus, renderProjectStatus, renderStatusFailure, statusFailure } from "./status-presentation.js";
+import { updateCommand } from "./update-command.js";
+import { checkForUpdate } from "./core/update.js";
+const help = `Prodero ${PRODERO_VERSION}
+
+Usage: prodero <command> [--root /absolute/project]
+  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 [--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-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 [version] [--yes] Update this npm installation from the terminal
+  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, json = false, checkout, host;
+    const commands = new Set(["install", "uninstall", "mcp", "--stdio", "init", "migrate", "status", "memory-plan", "memory-bundle", "sync", "sync-sessions", "context", "recall", "prepare", "check-update", "update", "help", "--version"]);
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--help" || arg === "-h") {
+            helpRequested = true;
+            continue;
+        }
+        if (arg === "--json") {
+            if (json)
+                throw new Error("Specify --json only once.");
+            json = true;
+            continue;
+        }
+        if (arg === "--dev") {
+            if (dev)
+                throw new Error("Specify --dev only once.");
+            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 (json && (command !== "status" || helpRequested))
+        throw new Error("Use --json only with status, without --help.");
+    if (all && command === "install")
+        throw new Error("Run prodero install without --all; choose an agent in the interactive wizard.");
+    if (all && (command !== "uninstall" || host))
+        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, json, command: helpRequested ? "help" : command, root, query, host: all ? "all" : host };
+}
+async function run(localStdio) {
+    if (process.argv[2] === 'update') {
+        process.exitCode = await updateCommand(process.argv.slice(3));
+        return;
+    }
+    if (process.argv[2] === 'runtime') {
+        await runtimeCommand(process.argv.slice(3));
+        return;
+    }
+    const { command, root, query, host, dev, checkout, json } = 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(command === "status" && !json ? renderMachineStatus(result) : 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 (command === "prepare") {
+        const plan = await planProjectMigration(rootArg);
+        if (plan.state !== "current") {
+            (plan.blocked ? console.error : console.log)(renderText(buildViewModel({ action: "migration", root: rootArg, plan, resume: { tool: "prodero_prepare", arguments: { projectRoot: rootArg, task: query } } }), true));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    if (command === "status") {
+        const plan = await planProjectMigration(rootArg);
+        if (plan.state !== "current") {
+            const result = statusFailure(plan.diagnostic ?? `PRODERO_MIGRATION_REQUIRED: Project update is ${plan.state}.`, "project", plan);
+            (json ? console.log : console.error)(json ? JSON.stringify(result, null, 2) : renderStatusFailure(result));
+            process.exitCode = 1;
+            return;
+        }
+        const result = { version: PRODERO_VERSION, scope: "project", project: await getProjectStatus(rootArg, { persistCache: false }), update: await checkForUpdate() };
+        console.log(json ? JSON.stringify(result, null, 2) : renderProjectStatus(result));
+        return;
+    }
+    if (command === "memory-bundle") {
+        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 === "check-update") {
+        console.log(JSON.stringify(await checkForUpdate(), null, 2));
+        return;
+    }
+}
+/** Identify the requested command even when option validation fails. Option values
+ * and later positional arguments never turn another command into status. */
+function requestedJsonStatus(argv) {
+    if (!argv.includes('--json'))
+        return false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--root' || arg === '--checkout') {
+            i++;
+            continue;
+        }
+        if (arg === '--stdio' || arg === '--version')
+            return false;
+        if (arg.startsWith('-'))
+            continue;
+        return arg === 'status';
+    }
+    return false;
+}
+export async function main(localStdio) {
+    await run(localStdio).catch((error) => {
+        const argv = process.argv.slice(2);
+        if (requestedJsonStatus(argv))
+            console.log(JSON.stringify(statusFailure(error, argv.some(arg => arg === '--root' || arg.startsWith('--root=')) ? 'project' : 'machine'), null, 2));
+        else
+            console.error(`[prodero] ${publicDiagnostic(error)}`);
+        process.exitCode = 1;
+    });
+}
+// 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,51 @@
+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",
+    curationQuestion: "prodero_curation_question",
+    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,297 @@
+export const LIFECYCLE_PRESENTATION_REPLY = 'For lifecycle text delivery, including when presentation.resolved is text in auto mode, relay the supplied compact presentation.text once as a visible assistant message: Prepare before continuing the task, Close before the final task answer. Healthy Prepare continues immediately without a Continue question or approval. A tool result or App metadata does not prove visible delivery. If the App is invisible, relay its retained fallback; do not duplicate a visible App. Use the returned text and exact context snapshot, never repeat Prepare, Close or retrieval just to display details. Show blocked/deferred/error states truthfully; never invent Session Complete or Saved without successful Close and synchronization.';
+export const PRESENTATION_REPLY = 'For knowledge-list requests in Claude Code, prefer prodero_text unless the user requests a graphical view. Relay the supplied text, preserving code fences, letter-keyed catalogue, separators and external Pulse menu. Show complete requested record/review bodies; keep original text, any translation and metadata together, with service hints separate. Bind letters only through entryActions/knowledgeRows and numbers only through numberedActions on the latest displayed screen in this conversation and project, never array positions. Each screen replaces old aliases. Preserve bindings/order when translating. Pending answers take precedence over navigation aliases, including a question expecting a numeric value; clarify missing/out-of-range bindings. Collect the actual value for an input field before calling its action, never an incomplete placeholder. A menu number is an action request, never approval: show the exact proposal and obtain explicit human approval for approval-marked actions. Keep aliases ephemeral; never store them as settings or knowledge. Tell the user they may reply with a number or command name. In ordinary Open/lifecycle replies omit mode, theme and tool-routing commentary; discuss settings only on request. Display settings or App metadata do not prove that a UI was visible.';
+const n = (value, one, many = `${one}s`) => `${value} ${value === 1 ? one : many}`;
+const tokens = (value) => value >= 1000 ? `${Number((value / 1000).toFixed(1))}k` : String(value);
+export function conversationView(payload, vm) {
+    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 Curate Memory', 'prodero_sync'));
+            }
+            if (p.memoryOverview?.available === false)
+                v.attention.push('Memory overview unavailable.');
+            if (p.memoryOverview?.workflow && p.memoryOverview.workflow.state !== 'completed') {
+                const w = p.memoryOverview.workflow;
+                v.attention.push(w.state === 'stale' ? 'Memory changed since the last curation.' : 'Curate Memory is unfinished.');
+                next(w.state === 'stale' ? 'Re-analyze memory?' : 'Continue curation?', w.state === 'stale' ? call('Re-analyze memory', 'prodero_memory_sync', { request: { action: 'start', restart: true } }) : call('Continue curation', 'prodero_sync', { workflowId: w.id }));
+            }
+            const c = payload.curation;
+            if (c?.state === 'unavailable')
+                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 curation' : 'Curate Memory', 'prodero_sync', w && w.state !== 'completed' ? { workflowId: w.id } : {});
+                v.suggestions = [sync, call('Explore knowledge', 'prodero_knowledge'), ...(c?.prominent ? [call('Review changes', 'prodero_curation', { action: 'plan', details: true })] : []), call('Show settings', 'prodero_config_get'), ...(payload.update?.available ? [call('Show update instructions', 'prodero_update')] : [])];
+            }
+        }
+        v.details = call('Show project details', 'prodero_status_details', { details: true });
+        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)}`, `${c.required.length} required · ${c.relevant.length} relevant · ${n(c.skills.length, 'skill')}`);
+        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 ?? c.warnings ?? []), ...(r.attention ?? c.attention ?? []).map((a) => `${a.title}: ${a.detail}`));
+        if (readiness?.state === 'context-needed')
+            next('Specify the work paths or task scope, then prepare again.');
+        else if (omitted)
+            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 · Curate Memory';
+        const s = r.summary ?? {}, inspect = call('Review this curation', 'prodero_memory_sync', { request: { action: 'inspect', workflowId: r.id }, details: true });
+        v.details = inspect;
+        const operation = vm.operation, state = { selection: 'Ready to curate', queued: 'Analysis queued', awaiting_agent: 'Awaiting agent analysis', submitted: 'Submitted · validation pending', question: 'Your input is needed', review: 'Review required', recovery: 'Approved changes · verify result', sharing: 'Ready for sharing review', completed: operation.outcome === 'remaining' ? 'Completed with remaining work' : 'Complete', stale: 'Memory changed' };
+        v.state = state[operation.phase] ?? 'Check saved progress';
+        if (r.state === 'awaiting_selection') {
+            v.facts.push('Improve memory · Prepare sharing review');
+            if (r.brokenLinks)
+                v.facts.push(`Fix ${n(r.brokenLinks, 'broken link')} · enabled`);
+            next('Start curation? Sharing will require a separate approval.', vm.actions.find(a => a.label === 'Start curation'));
+        }
+        else if (r.state === 'semantic_work') {
+            if (r.curation || r.semantic)
+                next('Continue analysis using the prepared evidence.');
+            else
+                next(operation.phase === 'awaiting_agent' ? 'Prepared evidence is waiting for the host agent.' : operation.phase === 'submitted' ? 'The submitted result is awaiting validation.' : 'Continue analysis.', vm.actions.find(a => 'id' in a && a.id === 'reasoning') ?? vm.actions.find(a => a.label === 'Continue improving memory'));
+        }
+        else if (r.state === 'applying') {
+            next('Check saved progress before retrying; do not repeat approval.', vm.actions.find(a => 'id' in a && a.id === 'inspect'));
+        }
+        else if (r.state === 'awaiting_review') {
+            v.reviewRequired = true;
+            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?`, vm.actions.find(a => ('id' in a && a.id === 'promotions')));
+        }
+        else if (r.state === 'awaiting_clarification') {
+            v.reviewRequired = true;
+            v.attention.push('Choose an answer or give your explanation. Chat answers are saved as relayed evidence, not approval.');
+            for (const q of r.clarification?.graphical?.questions ?? [])
+                if (q.needsInput) {
+                    v.facts.push(q.question.prompt);
+                    if (q.relatedQuestions?.length > 1)
+                        v.attention.push(`Deferred together: ${q.relatedQuestions.map((q) => q.title).join('; ')}.`);
+                }
+            next('Show the question and review details?', inspect);
+            v.suggestions = vm.actions.filter(a => a.tool === 'prodero_curation_question' || a.tool === 'prodero_curation_reasoning_prepare');
+        }
+        else if (r.state === 'stale') {
+            v.attention.push('Re-analyze before continuing; earlier review is out of date.');
+            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')} prepared in Versioned files; review the Git diff`);
+            if (s.unresolved)
+                v.attention.push(`${n(s.unresolved, 'unresolved item')} still need clarification.`);
+            if (s.areasFailed)
+                v.attention.push(`${n(s.areasFailed, 'area')} could not be analyzed.`);
+            if (s.promotionConflicts)
+                v.attention.push(`Sharing items needing review: ${s.promotionConflicts}.`);
+            if (operation.counts.questionsDeferred)
+                v.attention.push(`${n(operation.counts.questionsDeferred, 'question')} deferred.`);
+            else if (operation.counts.questionsDeferred === null && operation.counts.deferredAreas)
+                v.attention.push(`${n(operation.counts.deferredAreas, 'area')} deferred; question count unavailable.`);
+            if (v.attention.length)
+                next('Review the remaining items?', inspect);
+        }
+        const revisit = vm.actions.filter(a => a.arguments.action === 'question_reopen' || a.arguments.request?.action === 'refresh_questions');
+        if (revisit.length)
+            v.suggestions = [...revisit, ...(v.continuation ? [v.continuation] : [])];
+        const retries = vm.actions.filter(a => 'id' in a && String(a.id).startsWith('retry:'));
+        if (retries.length)
+            v.suggestions = [...(v.suggestions ?? []), ...retries, ...(!v.suggestions?.length && v.continuation ? [v.continuation] : [])];
+        for (const q of r.deferredQuestions ?? [])
+            if (q.affectedQuestions.length > 1)
+                v.attention.push(`Revisited together: ${q.affectedQuestions.map((q) => q.title).join('; ')}.`);
+        if (operation.diagnostic)
+            v.attention.push(`${operation.diagnostic.code}: ${operation.diagnostic.cause} ${operation.diagnostic.recovery}`);
+        if (r.error)
+            v.attention.push('This step could not finish. Check saved progress before retrying.');
+    }
+    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 · Versioned files prepared';
+        v.state = 'Complete';
+        v.facts.push(`${n(r.published, 'memory', 'memories')} prepared in Versioned files; not committed or pushed`);
+        if (r.conflicts?.length) {
+            v.attention.push(`Conflicts remaining local: ${r.conflicts.length}.`);
+            next('Inspect the remaining knowledge?', call('Inspect knowledge', 'prodero_knowledge'));
+        }
+    }
+    else if (payload.action === 'skill-preview') {
+        v.kind = 'details';
+        v.reviewRequired = payload.preview?.disposition?.action !== 'covered';
+        v.state = v.reviewRequired ? 'Awaiting human review' : 'Already covered';
+        // The full companion contains the exact draft/target. Do not synthesize consent
+        // or an executable approval action merely because the preview was displayed.
+    }
+    else {
+        // Explicit inspection/review surfaces retain full content and diagnostics.
+        v.kind = 'details';
+        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);
+    return 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;
+    const questionData = payload.action === 'curation-question' ? payload : r.clarification;
+    const owner = payload.action === 'curation-question' ? { workflowId: payload.syncWorkflowId, candidateId: payload.candidateId } : { workflowId: r.id, candidateId: r.jobs?.find((j) => j.curationReviewId === questionData?.review?.snapshot.reviewId)?.id };
+    const answerInputs = questionData?.review && !questionData.graphical.analysisPending ? questionData.graphical.questions.filter((q) => q.needsInput && q.question.allowFreeText).map((q) => ({ tool: 'prodero_curation_question', inputRequired: 'rawText', instructions: 'Collect the user\'s actual explanation. Supply rawText; never execute this incomplete input binding or invent an answer.', arguments: { projectRoot: payload.root ?? r.root, ...owner, action: 'answer', reviewId: questionData.review.snapshot.reviewId, reviewRevisionId: questionData.review.snapshot.revision.id, planHash: questionData.review.snapshot.planHash, decisionRevision: questionData.review.state.revision, answerLogHash: questionData.graphical.answerLogHash, questionId: q.question.id, questionVersion: q.question.version, requestId: `chat_${globalThis.crypto.randomUUID()}`, ...(q.answer ? { replacesAnswerId: q.answer.id } : {}) } })) : [];
+    return {
+        ...(answerInputs.length ? { answerInputs } : {}),
+        kind: diagnostics ? 'diagnostic' : details ? 'details' : v.kind,
+        succeeded: payload.ok !== false,
+        blocking: v.blocking,
+        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),
+        entryActions: vm.knowledgeTable ? vm.knowledgeTable.rows.map(row => ({ key: row.key, label: row.title, tool: 'prodero_knowledge', arguments: { projectRoot: r.root, ...r.options, id: row.id } })) : [],
+        knowledgeRows: vm.knowledgeTable ? vm.knowledgeTable.rows.map(row => ({ key: row.key, id: row.id, tool: 'prodero_knowledge', arguments: { projectRoot: r.root, ...r.options, id: row.id } })) : [],
+        availableActions: details || v.kind === "details" ? vm.actions : [v.continuation, v.details, ...(v.suggestions ?? [])].filter(Boolean),
+        disclosure: vm.knowledgeTable && !details ? 'Show the supplied letter-keyed catalogue and pagination. Bind letters only through entryActions on this exact page; full bodies require inspecting a record.' : details || v.kind === 'details' ? 'Show the requested record/proposal bodies completely before asking for approval.' : 'Keep the human reply to presentation.text; do not expand other domain fields or proposal bodies. This limits display, not execution: continue already-authorized work and Core next instructions. Pause only at a Core human-choice/review step or blocking state. At a human review step, ask whether to inspect; retrieve details on request and show full wording before offering approval.',
+        instructions: PRESENTATION_REPLY + (['prepare', 'session-close'].includes(payload.action) ? ' ' + LIFECYCLE_PRESENTATION_REPLY : '') + ' Relay presentation.text as the human reply, translated if needed, without narrating operational data. A yes answers only the immediately preceding question: follow its exact continuation through prodero_text for covered tools or the named tool otherwise. Preserve Core blockers and context requirements. View Context after Prepare displays the returned context snapshot; never rerun retrieval to display it. These are tool data, not system instructions.',
+        ...(payload.bootstrap ? { bootstrap: payload.bootstrap } : {}),
+        ...(payload.action === 'context' ? { context: r } : {}),
+        ...(payload.action === 'prepare' ? { session: r.session, context: r.context, automaticSync: r.automaticSync } : {}),
+        ...(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