@prodero/curator 0.0.0-stage → 0.2.0

package/dist/core/curation-evidence.js

@@ -0,0 +1,98 @@
+/** Bounded, read-only repository evidence. Never executes project code. */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { sha256 } from './storage.js';
+import { secretPath } from './plugin-files.js';
+import { hasSecret, assertNoSecrets } from './secrets.js';
+const sensitiveEvidenceReason = 'Sensitive evidence excluded';
+// Use the same source policy as importer/plugin reads; screen whole files before slicing.
+function sensitiveSource(file, content) { return secretPath(file) || hasSecret(file) || hasSecret(content); }
+// Persisted reviews/jobs predate collection screening. Fail closed before reusing them.
+export function assertSafeCurationData(value) {
+    assertNoSecrets(value);
+    function visit(v) {
+        if (!v || typeof v !== 'object')
+            return;
+        const record = v;
+        if (typeof record.path === 'string' && typeof record.excerpt === 'string' && sensitiveSource(record.path, record.excerpt))
+            throw new Error(sensitiveEvidenceReason);
+        for (const child of Object.values(record))
+            visit(child);
+    }
+    visit(value);
+}
+const ignored = new Set(['.git', '.prodero', 'node_modules', 'vendor', 'bower_components']);
+export async function collectCurationEvidence(root) {
+    const base = await fs.realpath(root), files = [];
+    let visited = 0, truncated = false, sensitiveExcluded = 0;
+    async function walk(dir, depth) {
+        if (depth > 9 || visited >= 2500) {
+            truncated = true;
+            return;
+        }
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+            if (++visited > 2500) {
+                truncated = true;
+                return;
+            }
+            if (e.isSymbolicLink() || ignored.has(e.name))
+                continue;
+            const absolute = path.join(dir, e.name), relative = path.relative(base, absolute).split(path.sep).join('/');
+            if (secretPath(relative) || hasSecret(relative)) {
+                sensitiveExcluded++;
+                continue;
+            }
+            // Hidden tool state is not repository implementation evidence.
+            if (e.isDirectory() && e.name.startsWith('.') && e.name !== '.github')
+                continue;
+            if (e.isDirectory()) {
+                await walk(absolute, depth + 1);
+                continue;
+            }
+            if (!/\.(?:php|js|cjs|mjs|jsx|ts|tsx|sh|md|xml|py|rb|go|rs|java|kt|c|h|cpp|cs|swift|sql|html|css|vue|svelte|json|ya?ml|toml)$/i.test(e.name))
+                continue;
+            const st = await fs.lstat(absolute);
+            if (!st.isFile() || st.size > 300000)
+                continue;
+            // Recheck real containment: referenced symlinks may not escape the project.
+            const real = await fs.realpath(absolute);
+            if (!real.startsWith(base + path.sep))
+                continue;
+            const content = await fs.readFile(real, 'utf8');
+            if (sensitiveSource(relative, content)) {
+                sensitiveExcluded++;
+                continue;
+            }
+            files.push({ path: relative, revision: sha256(content), content });
+        }
+    }
+    // One bounded traversal treats repository layouts uniformly.
+    await walk(base, 0);
+    return { root: base, files, truncated, sensitiveExcluded };
+}
+export function evidenceFor(content, inventory) {
+    const symbols = new Set((content.match(/\b[A-Za-z_][A-Za-z0-9_]*\b/g) ?? []).filter(s => s.length > 4).map(s => s.toLowerCase()));
+    const results = [];
+    for (const f of inventory.files) {
+        if (sensitiveSource(f.path, f.content))
+            continue;
+        const lines = f.content.split('\n');
+        for (let i = 0; i < lines.length; i++)
+            if ((lines[i].match(/\b[A-Za-z_][A-Za-z0-9_]*\b/g) ?? []).some(s => symbols.has(s.toLowerCase()))) {
+                results.push({ path: f.path, revision: f.revision, line: i + 1, excerpt: lines[i].trim().slice(0, 300), kind: /test/i.test(f.path) ? 'test' : /grunt|deploy/i.test(f.path) ? 'build' : 'implementation' });
+                if (results.length >= 30 || results.filter(r => r.path === f.path).length >= 3)
+                    break;
+            }
+        if (results.length >= 30)
+            break;
+    }
+    return results;
+}
+//# sourceMappingURL=curation-evidence.js.map

package/dist/core/curation-graphical.js

@@ -0,0 +1,117 @@
+/** First-party App orchestration. Local review state only; never grants or writes knowledge. */
+import { z } from 'zod';
+import { withSyncLock, ownsSyncLock } from './sync-transaction.js';
+import { loadCurationReview, curationReviewView, stageCurationDecisions, stageEvent, assertCurationHead, CurationReviewError } from './curation-review.js';
+import { curationAnswers, appendCurationAnswer, semanticJobs, semanticJobStatus, semanticJobSuspended, semanticRetryState, prepareSemanticCuration } from './curation-semantic-jobs.js';
+import { revisionIssues, selectionProblems, deterministicBaseline } from './curation-revision.js';
+import { planKnowledgeCuration } from './knowledge-curation.js';
+import { semanticHash } from './curation-semantic-contract.js';
+const identity = { reviewId: z.string(), reviewRevisionId: z.string(), planHash: z.string(), decisionRevision: z.number().int().nonnegative(), answerLogHash: z.string() };
+export const graphicalActionSchema = z.object({ ...identity, action: z.enum(['summary', 'analyze', 'answer', 'question_later', 'question_reopen', 'retry_analysis']), questionId: z.string().optional(), questionVersion: z.number().int().positive().optional(), choiceId: z.string().optional(), rawText: z.string().max(8192).optional(), requestId: z.string().min(1).max(100).optional(), replacesAnswerId: z.string().optional() }).strict();
+const pending = (status) => ['prepared', 'awaiting_reasoning', 'submitted'].includes(status);
+export async function graphicalReviewState(root, review, projection) {
+    const revision = review.snapshot.revision;
+    if (!revision)
+        return undefined;
+    const answers = await curationAnswers(root, revision.lineageId), allJobs = await semanticJobs(root);
+    const questions = projection.clarificationCandidates.map(q => {
+        const units = projection.items.filter(u => u.proposalIds.some(id => q.sourceIds.includes(id)));
+        const answer = [...answers].reverse().find(a => a.questionId === q.question.id && a.basisHash === q.basisHash && !answers.some(next => next.replacesAnswerId === a.id));
+        return { ...q, unitIds: units.map(u => u.id), componentId: revision.dependencies.groups.find(g => g.proposalIds.some(id => q.sourceIds.includes(id)))?.component, answer };
+    });
+    const jobs = allJobs.filter(j => j.input.reviewRevisionId === revision.id && !allJobs.some(next => next.input.previousJobId === j.input.jobId)).map(j => {
+        const event = j.events.at(-1);
+        const suspended = semanticJobSuspended(j, review);
+        const status = semanticJobStatus(j, review);
+        return { id: j.input.jobId, componentId: j.input.bundle.componentId, status, reason: event.reason, suspended, ...semanticRetryState(j, review, allJobs) };
+    });
+    const actionable = jobs.filter(j => !j.suspended && j.status !== 'validated');
+    const unansweredComponents = revision.dependencies.groups.filter(g => projection.items.some(u => u.id === g.id && u.needsInput) && !questions.some(q => q.componentId === g.component));
+    const awaiting = questions.find(q => q.state === 'answered_pending_analysis');
+    const componentId = awaiting?.componentId ?? unansweredComponents[0]?.component;
+    const activeQuestions = questions.filter(q => q.needsInput);
+    const answered = new Set(revision.answerBindings.map(a => a.answerEventId));
+    const clarifiedWithYou = new Set(answers.filter(a => answered.has(a.id) && !revisionIssues(revision).some(i => i.sourceIds.some(id => a.sourceIds.includes(id)))).map(a => a.issueId)).size;
+    return { version: 1, questions: questions.map(q => ({ ...q,
+            // Deferral requires every affected unit to become deferred/kept; reopening
+            // any unit can reactivate an overlapping question. These effects differ.
+            relatedQuestions: questions.filter(other => other.state !== 'deferred' && other.unitIds.some(id => q.unitIds.includes(id)) && other.unitIds.every(id => q.unitIds.includes(id) || projection.items.some(u => u.id === id && (u.issue?.state === 'deferred' || u.disposition === 'keep_current')))).map(other => ({ id: other.question.id, version: other.question.version, title: other.question.title })),
+            reopenedQuestions: questions.filter(other => (other.state === 'deferred' || other.disposition === 'keep_current') && other.unitIds.some(id => q.unitIds.includes(id))).map(other => ({ id: other.question.id, version: other.question.version, title: other.question.title })),
+            position: activeQuestions.findIndex(a => a.question.id === q.question.id) + 1 })), activeQuestionIds: activeQuestions.map(q => q.question.id), activeQuestionCount: activeQuestions.length, deferredQuestionIds: questions.filter(q => q.state === 'deferred').map(q => q.question.id), answerLogHash: semanticHash(answers), clarifiedWithYou,
+        jobs, continuationJobId: actionable.find(j => pending(j.status))?.id, analysisFailed: actionable.some(j => !pending(j.status)), analysisPending: actionable.some(j => pending(j.status)) || !!awaiting && !actionable.some(j => !pending(j.status)),
+        canRetryAnalysis: actionable.some(j => j.canRetry || j.canResume),
+        nextAnalysisComponent: componentId, needsPreparation: !!componentId && !actionable.some(j => j.componentId === componentId),
+        filters: { ready: projection.items.filter(i => i.ready).map(i => i.id), clarification: projection.items.filter(i => i.outcome === 'unresolved').map(i => i.id), deferred: projection.items.filter(i => i.disposition === 'deferred').map(i => i.id), unchanged: projection.items.filter(i => i.outcome === 'unchanged').map(i => i.id), applied: projection.items.filter(i => i.execution === 'applied').map(i => i.id) },
+        repositoryChanges: projection.items.filter(i => i.ready && i.proposalIds.some(id => !review.snapshot.plan.proposals.find(p => p.id === id).path.startsWith('local/'))).length, policyEffectChanges: projection.items.filter(i => i.ready && i.proposalIds.some(id => review.snapshot.plan.proposals.find(p => p.id === id).changes.some(c => c.startsWith('applicability-')))).length,
+        packageReady: projection.readyChangeGroups === projection.included && projection.canApply, packageCount: projection.included,
+        remaining: projection.unresolvedIssueCount > 0 || projection.deferredChanges > 0 || projection.readyChangeGroups > 0 };
+}
+export async function graphicalReviewPayload(root, review) {
+    const view = await curationReviewView(root, review.snapshot.plan, review);
+    return { action: 'curation', root, plan: review.snapshot.plan, ...view, graphical: await graphicalReviewState(root, view.review, view.projection), appReviewAvailable: true };
+}
+export async function graphicalReviewAction(root, raw, answerOrigin = 'app') {
+    const input = graphicalActionSchema.parse(raw);
+    const operation = async () => {
+        let review = await loadCurationReview(root, input.reviewId);
+        const revision = review.snapshot.revision;
+        await assertCurationHead(root, review);
+        if (!revision || revision.id !== input.reviewRevisionId || review.snapshot.planHash !== input.planHash || review.state.revision !== input.decisionRevision)
+            throw new CurationReviewError('review_changed', 'This review changed. Reload saved decisions.');
+        const answers = await curationAnswers(root, revision.lineageId);
+        const replay = input.action === 'answer' && answers.find(a => a.requestId === input.requestId);
+        if (!replay && semanticHash(answers) !== input.answerLogHash)
+            throw new CurationReviewError('review_changed', 'Another answer was saved. Reload this review.');
+        let view = await graphicalReviewPayload(root, review), g = view.graphical;
+        const question = g.questions.find(q => q.question.id === input.questionId && q.question.version === input.questionVersion);
+        if (['answer', 'question_later', 'question_reopen'].includes(input.action) && !question)
+            throw new CurationReviewError('review_changed', 'This question changed. Reload the review.');
+        if (input.action === 'summary') {
+            const selected = view.projection.items.filter(i => i.ready).flatMap(i => i.proposalIds);
+            if (selectionProblems(revision.dependencies, selected).length)
+                throw new CurationReviewError('dependency_blocked', 'Some changes depend on unresolved information.');
+            const decisions = Object.fromEntries(view.projection.items.filter(i => i.ready && i.disposition !== 'included').map(i => [i.id, 'suggested']));
+            if (Object.keys(decisions).length)
+                review = await stageCurationDecisions(root, { ...input, decisions });
+        }
+        else if (input.action === 'question_later' || input.action === 'question_reopen') {
+            const baseline = deterministicBaseline(revision);
+            if ((await planKnowledgeCuration(root, { memorySyncSources: baseline.memorySyncSources })).planId !== baseline.planId)
+                throw new CurationReviewError('semantic_stale', 'Knowledge or evidence changed. Review the current question.');
+            if (input.action === 'question_reopen' && question.state !== 'deferred')
+                throw new CurationReviewError('review_changed', 'This question is not deferred. Reload the saved review.');
+            review = await stageEvent(root, input, input.action === 'question_later' ? 'defer_issue' : 'reopen_issue', Object.fromEntries(question.unitIds.map(id => [id, 'deferred'])));
+        }
+        else {
+            if (input.action === 'answer') {
+                if (!input.requestId)
+                    throw new CurationReviewError('semantic_invalid', 'Answer request identity is missing.');
+                if (!replay && (!question.needsInput || g.analysisPending))
+                    throw new CurationReviewError('review_changed', 'This answer is already being reviewed.');
+                await appendCurationAnswer(root, { reviewId: input.reviewId, reviewRevisionId: input.reviewRevisionId, decisionRevision: input.decisionRevision, answerLogHash: input.answerLogHash, questionId: input.questionId, questionVersion: input.questionVersion, requestId: input.requestId, origin: answerOrigin, choiceId: input.choiceId, rawText: input.rawText, replacesAnswerId: input.replacesAnswerId });
+                // Answer is durable before job preparation. A capacity/dispatch failure cannot erase it.
+                view = await graphicalReviewPayload(root, review);
+                g = view.graphical;
+            }
+            const failed = g.jobs.find(j => !j.suspended && (j.canRetry || j.canResume)), component = input.action === 'answer' ? question.componentId : input.action === 'retry_analysis' ? failed?.componentId : g.nextAnalysisComponent;
+            if (!component) {
+                if (g.continuationJobId)
+                    return view;
+                throw new CurationReviewError('semantic_limit', 'No further automatic analysis is available. Review details or answer later.');
+            }
+            try {
+                const job = await prepareSemanticCuration(root, { reviewId: review.snapshot.reviewId, reviewRevisionId: revision.id, componentId: component, requestId: input.requestId ?? `app_${semanticHash([revision.id, review.state.revision, g.answerLogHash, component, input.action, ...(input.action === 'retry_analysis' ? [failed.id] : [])])}`, reason: input.action === 'retry_analysis' ? (failed.canRetry ? 'validation_correction' : 'resume') : input.action === 'answer' ? 'answer' : g.questions.some(q => q.state === 'answered_pending_analysis') ? 'resume' : 'initial', ...(input.action === 'retry_analysis' ? failed.canRetry ? { correctionForJobId: failed.id } : { resumeForJobId: failed.id } : {}) });
+                view = await graphicalReviewPayload(root, review);
+                return { ...view, continuationJobId: pending(job.status) ? job.jobId : undefined, analysisNotice: pending(job.status) ? undefined : 'No further progress was possible with the current information.' };
+            }
+            catch (error) {
+                if (!(error instanceof CurationReviewError))
+                    throw error;
+                return { ...await graphicalReviewPayload(root, review), analysisNotice: input.action === 'answer' ? 'Answer saved. Analysis needs more information or has reached its limit.' : error.message };
+            }
+        }
+        return graphicalReviewPayload(root, review);
+    };
+    return ownsSyncLock(root) ? operation() : withSyncLock(root, operation, { recoverLifecycle: false, waitMs: 2000 });
+}
+//# sourceMappingURL=curation-graphical.js.map

package/dist/core/curation-question.js

@@ -0,0 +1,28 @@
+/** Model-visible Sync question adapter. Staging only; no selection or Apply. */
+import { z } from 'zod';
+import { graphicalActionSchema, graphicalReviewAction } from './curation-graphical.js';
+import { syncCurationReview } from './memory-sync.js';
+import { withSyncLock } from './sync-transaction.js';
+import { curationAnswers } from './curation-semantic-jobs.js';
+const owner = { workflowId: z.string().uuid(), candidateId: z.string().regex(/^area_[a-f0-9]{20}$/) };
+const actions = z.enum(['analyze', 'answer', 'question_later', 'question_reopen', 'retry_analysis']);
+export const curationQuestionSchema = z.union([
+    graphicalActionSchema.extend({ ...owner, action: actions }).strict(),
+    z.object({ ...owner, action: z.literal('inspect'), reviewId: z.string().regex(/^review_[a-zA-Z0-9_]+$/) }).strict(),
+]);
+// MCP requires an object-root schema. The strict action-specific union is
+// checked inside the same operation before ownership or journal mutations.
+export const curationQuestionToolSchema = graphicalActionSchema.extend({ ...owner, action: z.enum(['inspect', ...actions.options]), reviewRevisionId: graphicalActionSchema.shape.reviewRevisionId.optional(), planHash: graphicalActionSchema.shape.planHash.optional(), decisionRevision: graphicalActionSchema.shape.decisionRevision.optional(), answerLogHash: graphicalActionSchema.shape.answerLogHash.optional() }).strict();
+export async function runCurationQuestion(root, raw) {
+    const input = curationQuestionSchema.parse(raw);
+    return withSyncLock(root, async () => {
+        const { workflowId, candidateId, ...request } = input;
+        const saved = await syncCurationReview(root, workflowId, candidateId, request.reviewId);
+        const payload = request.action === 'inspect' ? saved : await graphicalReviewAction(root, request, 'agent_relay');
+        const answer = request.action === 'answer' ? (await curationAnswers(root, payload.review.snapshot.revision.lineageId)).find(a => a.requestId === request.requestId) : undefined;
+        return { ...payload, action: 'curation-question', syncWorkflowId: workflowId, candidateId, appReviewAvailable: false,
+            ...(answer ? { answerAcknowledgement: { answerId: answer.id, origin: answer.origin, saved: true, message: 'Relayed chat answer saved. It is evidence for staged analysis, not authenticated human intent or approval.' } } : {}),
+            next: { tool: 'prodero_memory_sync', arguments: { projectRoot: root, request: { action: 'inspect', workflowId } }, instructions: 'Inspect this saved Sync workflow after the bounded reasoning continuation. Relayed answers remain evidence, not approval; unresolved facts may still need clarification or deliberate deferral. Never Apply, promote or publish on the strength of an answer.' } };
+    }, { recoverLifecycle: false, waitMs: 2000 });
+}
+//# sourceMappingURL=curation-question.js.map

package/dist/core/curation-review-presentation.js

@@ -0,0 +1,4 @@
+export function renderReviewProjection(p) {
+    return `${p.analyzedSourceCount} knowledge items · ${p.readyChangeGroups} proposed change groups · ${p.needsInputNow} need your input · ${p.deferredQuestions} deferred questions · ${p.deferredChanges} deferred changes · ${p.unchanged} unchanged${p.blockedGroups ? ` · ${p.blockedGroups} blocked change groups` : ''}${p.applied ? ` · ${p.applied} applied` : ''}${p.semanticAnalysisPending ? ` · ${p.semanticAnalysisPending} semantic analysis pending` : ''}${p.semanticAnalysisFailed ? ` · ${p.semanticAnalysisFailed} semantic analysis failed` : ''}${p.semanticProposalsReady ? ` · ${p.semanticProposalsReady} staged semantic candidates (structural validation only)` : ''}${p.additionalEvidenceRequired?.length ? ' · Additional evidence required' : ''}${p.paused ? ' · Review paused' : ''}`;
+}
+//# sourceMappingURL=curation-review-presentation.js.map

package/dist/core/curation-review-state.js

@@ -0,0 +1,62 @@
+import { deriveDependencies, selectionProblems, curationSelectionHash, revisionIssues } from './curation-revision.js';
+import { z } from 'zod';
+export const clarificationStateSchema = z.enum(['open', 'answered_pending_analysis', 'resolved', 'deferred', 'superseded']);
+export function analysisOutcome(plan, unit) {
+    const proposals = unit.proposalIds.map(id => plan.proposals.find(p => p.id === id));
+    if (unit.attention || proposals.some(p => p.outputs.some(o => o.applicability?.kind === 'unresolved')))
+        return 'unresolved';
+    return unit.applicable ? 'proposed' : 'unchanged';
+}
+/** The one attention/count/lifecycle policy. UI and text render this result verbatim. */
+export function projectCurationReview(plan, units, state, options = {}) {
+    const dependencies = options.legacy ? undefined : options.revision?.dependencies ?? deriveDependencies(plan, units);
+    const consumed = !!options.revision && Object.values(state.items).some(i => i.execution === 'applied');
+    const semanticIssues = revisionIssues(options.revision);
+    const items = units.map(unit => {
+        const persisted = state.items[unit.id];
+        const answerPending = semanticIssues.some(issue => options.semantic?.answeredIssueIds?.includes(issue.id) && unit.proposalIds.some(id => issue.sourceIds.includes(id)));
+        const item = answerPending && persisted.issue ? { ...persisted, issue: { ...persisted.issue, state: 'answered_pending_analysis' } } : persisted;
+        const needsInput = item.outcome === 'unresolved' && item.issue?.state === 'open' && item.disposition !== 'keep_current' && item.disposition !== 'deferred' && item.execution !== 'applied';
+        const dependency = dependencies?.groups.find(g => g.id === unit.id);
+        const blocked = !!options.semantic?.blockedGroupIds.includes(unit.id) || !!dependency && (dependency.blockedByIssueIds.length > 0 || dependency.incomplete.length > 0 || dependency.requires.some(id => ['keep_current', 'deferred'].includes(state.items[id]?.disposition ?? '')));
+        const ready = !consumed && !options.semantic?.blockedGroupIds.includes(unit.id) && !blocked && item.outcome === 'proposed' && item.disposition !== 'keep_current' && item.disposition !== 'deferred' && item.execution !== 'applied';
+        return { ...unit, ...item, blocked: item.outcome === 'proposed' && blocked, blockedReason: blocked ? 'Depends on unresolved information or incomplete evidence.' : null, needsInput: needsInput && !state.paused, ready: ready && !state.paused && !options.stale,
+            pendingDecision: item.execution !== 'applied' && item.outcome === 'proposed' && item.disposition === null };
+    });
+    const count = (predicate) => items.filter(predicate).length;
+    const analyzedSourceCount = options.revision?.analyzedSourceIds.length ?? new Set(plan.proposals.map(p => p.sourceId)).size;
+    const unchanged = plan.proposals.filter(p => !p.changes.length && !p.attention.length && !p.outputs.some(o => o.applicability?.kind === 'unresolved')).length;
+    let needsInputNow = count(i => i.needsInput);
+    let deferredQuestions = count(i => i.outcome === 'unresolved' && i.issue?.state === 'deferred');
+    const deferredChanges = count(i => i.outcome === 'proposed' && i.disposition === 'deferred');
+    const keptCurrent = count(i => i.disposition === 'keep_current');
+    const proposed = count(i => i.outcome === 'proposed');
+    const readyChangeGroups = count(i => i.ready);
+    const applied = count(i => i.execution === 'applied') + (options.revision?.appliedHistory.length ?? 0);
+    const semanticAnalysisPending = options.semantic?.pending ?? 0, semanticAnalysisFailed = options.semantic?.failed ?? 0;
+    const clarificationCandidates = semanticIssues.map(issue => {
+        const affected = items.filter(i => i.proposalIds.some(id => issue.sourceIds.includes(id)));
+        const kept = affected.length > 0 && affected.every(i => i.disposition === 'keep_current');
+        const deferred = !kept && affected.length > 0 && affected.every(i => i.issue?.state === 'deferred' || i.disposition === 'keep_current');
+        const questionState = options.semantic?.answeredIssueIds?.includes(issue.id) ? 'answered_pending_analysis' : deferred ? 'deferred' : 'open';
+        return { ...issue, state: questionState, disposition: kept ? 'keep_current' : deferred ? 'deferred' : null, needsInput: !state.paused && !kept && questionState === 'open' };
+    });
+    if (semanticIssues.length) {
+        const uncovered = items.filter(i => !semanticIssues.some(issue => i.proposalIds.some(id => issue.sourceIds.includes(id))));
+        needsInputNow = clarificationCandidates.filter(i => i.needsInput).length + uncovered.filter(i => i.needsInput).length;
+        deferredQuestions = clarificationCandidates.filter(i => i.state === 'deferred').length + uncovered.filter(i => i.issue?.state === 'deferred').length;
+    }
+    const analysisPending = (state.analysis === 'pending' ? 1 : count(i => i.issue?.state === 'answered_pending_analysis' && !options.semantic?.answeredIssueIds?.length)) + semanticAnalysisPending;
+    const analysisFailed = (state.analysis === 'failed' ? 1 : 0) + semanticAnalysisFailed;
+    const selectedIds = items.filter(i => i.ready && i.disposition === 'included').flatMap(i => i.proposalIds).sort();
+    const selectionIssues = dependencies ? selectionProblems(dependencies, selectedIds) : [];
+    const included = count(i => i.ready && i.disposition === 'included');
+    const outstanding = count(i => i.execution !== 'applied' && i.outcome !== 'unchanged');
+    const lifecycle = options.stale ? 'stale' : state.paused ? 'paused' : analysisFailed ? 'analysis_failed' : analysisPending ? 'analyzing' : applied ? (outstanding ? 'partially_applied' : 'completed') : needsInputNow ? (readyChangeGroups ? 'partially_ready' : 'awaiting_input') : readyChangeGroups ? 'ready' : count(i => i.blocked) ? 'awaiting_input' : deferredQuestions || deferredChanges ? 'ready' : 'completed';
+    return { version: 1, semanticAnalysisPending, semanticAnalysisFailed, clarificationCandidates, semanticProposalsReady: options.revision?.typedPlan.kind === 'semantic-v2' ? items.filter(i => i.ready && plan.proposals.some(p => i.proposalIds.includes(p.id) && p.changes.includes('semantic-candidate'))).length : 0, additionalEvidenceRequired: options.revision?.typedPlan.kind === 'semantic-v2' ? options.revision.typedPlan.analyses.flatMap((a, index, all) => a.proposal.additionalEvidenceRequired.filter(missing => !all.slice(index + 1).some(next => missing.sourceIds.some(id => next.bundle.expectedSources.some(s => s.id === id))))) : [], semanticValidation: options.revision?.typedPlan.kind === 'semantic-v2' ? 'structurally_validated_candidate' : undefined, unresolvedIssueCount: clarificationCandidates.length + items.filter(i => i.outcome === 'unresolved' && !semanticIssues.some(issue => i.proposalIds.some(id => issue.sourceIds.includes(id)))).length, reviewRevisionId: options.revision?.id, parentRevisionId: options.revision?.parentRevisionId, lineageId: options.revision?.lineageId, selectionHash: options.revision ? curationSelectionHash(options.revision.id, state.revision, selectedIds) : undefined, blockedGroups: count(i => i.blocked), selectionIssues, analyzedSourceCount, unchanged, proposed, readyChangeGroups, needsInputNow, deferredQuestions, keptCurrent, deferredChanges, analysisPending, analysisFailed, applied, included,
+        pendingDecisions: count(i => i.pendingDecision), unresolved: count(i => i.outcome === 'unresolved'),
+        paused: state.paused, lifecycle, selectedIds, canApply: selectedIds.length > 0 && state.analysis === 'complete' && !selectionIssues.length,
+        attentionUnitIds: items.filter(i => i.needsInput).map(i => i.id), items };
+}
+export { renderReviewProjection } from './curation-review-presentation.js';
+//# sourceMappingURL=curation-review-state.js.map