onto-mcp 0.4.11 → 0.4.13

package/dist/tui/view-model/review-adapter.js

@@ -0,0 +1,270 @@
+import { REVIEW_PROGRESS_STEPS, } from "../../core-api/review-progress.js";
+/** Phase that collects units the projection has not bound to a progress step. */
+const UNCATEGORIZED_PHASE_ID = "unassigned";
+const UNCATEGORIZED_PHASE_LABEL = "unassigned units";
+/** Canonical progress-step ids — used to reject non-step `completed_steps` keys. */
+const VALID_PROGRESS_STEP_IDS = new Set(REVIEW_PROGRESS_STEPS.map((step) => step.id));
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Narrow the `unknown` presentation payload to the read-only fields we use. */
+function readProgressPresentationInput(status) {
+    const input = status.llmPresentation?.progress?.input;
+    return isRecord(input) ? input : {};
+}
+/**
+ * Map a runtime unit status to the shared {@link NodeState}. `retrying` and
+ * `running_stale` are both still in-flight (the HUD surfaces the retry count /
+ * stale signal age separately), so they collapse to `running`.
+ */
+function unitStatusToNodeState(unitStatus) {
+    switch (unitStatus) {
+        case "pending":
+            return "pending";
+        case "running":
+        case "retrying":
+        case "running_stale":
+            return "running";
+        case "completed":
+            return "completed";
+        case "failed":
+            return "failed";
+    }
+}
+function unitToNode(unit) {
+    return {
+        id: unit.unitId,
+        label: unit.publicAlias,
+        status: unitStatusToNodeState(unit.status),
+        kind: unit.unitKind,
+        signalAgeSec: unit.secondsSinceLatestSignal,
+        attempts: unit.attemptCount,
+        failureMessage: unit.failureMessage,
+        outputPath: drillDownPath(unit),
+    };
+}
+/**
+ * Drill-down target for a unit. A completed unit's authored output is the
+ * authoritative artifact. For an active/failed unit that planned output may not
+ * exist yet, so prefer the live running-log (the projection only sets
+ * `runningLogRef` when that file is present) and fall back to the planned output.
+ */
+function drillDownPath(unit) {
+    if (unit.status === "completed") {
+        return unit.outputPath ?? unit.runningLogRef ?? null;
+    }
+    return unit.runningLogRef ?? unit.outputPath ?? null;
+}
+/**
+ * State of the current (in-flight) progress step, given the workflow's own
+ * status: a halted or failed run is terminal, and its current step is the
+ * halt/failure locus — surface that rather than a misleading "running". A live
+ * run's current step is running.
+ */
+function currentStepState(workflowStatus) {
+    if (workflowStatus === "failed")
+        return "failed";
+    if (workflowStatus === "halted")
+        return "halted";
+    return "running";
+}
+/**
+ * Phase state from its nodes (+ the projection's completed step ids). A failed
+ * node fails the phase; any in-flight node makes it running; a step listed in
+ * `completed_steps` (or all nodes completed) completes it; a halted node halts
+ * it. A step at the current step whose units exist but have not signalled yet
+ * takes the workflow's current-step state — matching {@link emptyStepState}'s
+ * current-step branch so the same current step reports the same state whether or
+ * not it carries units. Otherwise it is pending.
+ */
+function derivePhaseState(nodes, stepId, completedStepIds, stepNumber, currentStep, workflowStatus) {
+    if (nodes.some((node) => node.status === "failed"))
+        return "failed";
+    if (nodes.some((node) => node.status === "running"))
+        return "running";
+    if (nodes.some((node) => node.status === "halted"))
+        return "halted";
+    if (stepId !== null && completedStepIds.has(stepId))
+        return "completed";
+    if (nodes.length > 0 && nodes.every((node) => node.status === "completed")) {
+        return "completed";
+    }
+    if (nodes.length > 0 && nodes.every((node) => node.status === "skipped")) {
+        return "skipped";
+    }
+    if (stepNumber != null && currentStep != null && stepNumber === currentStep) {
+        return currentStepState(workflowStatus);
+    }
+    return "pending";
+}
+/**
+ * State for a progress step that has no bound units: completed when the workflow
+ * itself completed, when the step is in `completed_steps`, or when it sits before
+ * the current step; the workflow's current-step state at the current step (so a
+ * halted/failed run points at its halt/failure locus, not a phantom "running");
+ * otherwise pending. This keeps idle/completed steps visible so the HUD shows the
+ * whole pipeline (not only the steps that happened to carry units).
+ */
+function emptyStepState(stepId, stepNumber, completedStepIds, currentStep, workflowStatus) {
+    if (workflowStatus === "completed")
+        return "completed";
+    if (completedStepIds.has(stepId))
+        return "completed";
+    if (currentStep != null) {
+        if (stepNumber < currentStep)
+            return "completed";
+        if (stepNumber === currentStep)
+            return currentStepState(workflowStatus);
+    }
+    return "pending";
+}
+/**
+ * Emit a phase for EVERY progress step (in canonical order), attaching any units
+ * bound to it, so completed/idle steps stay visible. Units the projection left
+ * unbound (`progressStepId === null`) collect into a trailing uncategorized phase.
+ */
+function derivePhases(status, completedStepIds, currentStep, workflowStatus) {
+    const byStep = new Map();
+    for (const unit of status.unitProgress ?? []) {
+        const key = unit.progressStepId;
+        const bucket = byStep.get(key);
+        if (bucket)
+            bucket.push(unitToNode(unit));
+        else
+            byStep.set(key, [unitToNode(unit)]);
+    }
+    const phases = REVIEW_PROGRESS_STEPS.map((spec) => {
+        const nodes = byStep.get(spec.id) ?? [];
+        const state = nodes.length > 0
+            ? derivePhaseState(nodes, spec.id, completedStepIds, spec.step, currentStep, workflowStatus)
+            : emptyStepState(spec.id, spec.step, completedStepIds, currentStep, workflowStatus);
+        return { id: spec.id, label: spec.label, state, nodes };
+    });
+    const unassigned = byStep.get(null);
+    if (unassigned && unassigned.length > 0) {
+        phases.push({
+            id: UNCATEGORIZED_PHASE_ID,
+            label: UNCATEGORIZED_PHASE_LABEL,
+            state: derivePhaseState(unassigned, null, completedStepIds, null, currentStep, workflowStatus),
+            nodes: unassigned,
+        });
+    }
+    return phases;
+}
+/**
+ * Map the review status union to the shared {@link WorkflowStatus}. A degraded
+ * completion is still a completion; `halted_partial` is the operator-facing halt;
+ * `prepared` / `unknown` are pre-run states the HUD shows as still-running (the
+ * narrator/liveness convey the finer state).
+ */
+function deriveWorkflowStatus(status) {
+    switch (status) {
+        case "completed":
+        case "completed_with_degradation":
+            return "completed";
+        case "halted_partial":
+            return "halted";
+        case "failed":
+            return "failed";
+        case "running":
+        case "prepared":
+        case "unknown":
+            return "running";
+    }
+}
+/**
+ * Run control from the review projection. `cancellationAvailable` /
+ * `continuationAvailable` are the authoritative flags; review has no per-round
+ * advance, so `advanceable` is left undefined.
+ */
+function deriveRunControl(runControl) {
+    return {
+        cancellable: runControl?.cancellationAvailable ?? false,
+        continuable: runControl?.continuationAvailable ?? false,
+    };
+}
+const EMPTY_SEVERITY_COUNTS = {
+    blocker: 0,
+    high: 0,
+    medium: 0,
+    low: 0,
+    info: 0,
+};
+/**
+ * Footer findings: severity counts + material issue titles. Works for both the
+ * full and compact result-classification projections — material titles come from
+ * `material_issues[]` (full) or `material_issue_signals[]` (compact).
+ */
+function deriveFindings(summary) {
+    if (!summary) {
+        return { ...EMPTY_SEVERITY_COUNTS, material: [] };
+    }
+    const counts = {
+        blocker: summary.severity_counts.blocker,
+        high: summary.severity_counts.high,
+        medium: summary.severity_counts.medium,
+        low: summary.severity_counts.low,
+        info: summary.severity_counts.info,
+    };
+    return { ...counts, material: materialIssueTitles(summary) };
+}
+function isCompactSummary(summary) {
+    return "material_issue_signals" in summary;
+}
+function materialIssueTitles(summary) {
+    if (isCompactSummary(summary)) {
+        return summary.material_issue_signals.map((signal) => titleLine(signal.issue_id, signal.signal));
+    }
+    return summary.material_issues.map((issue) => titleLine(issue.issue_id, issue.problem_definition ?? issue.issue_statement ?? issue.impact));
+}
+function titleLine(issueId, text) {
+    const trimmed = (text ?? "").trim();
+    return trimmed.length > 0 ? `${issueId}: ${trimmed}` : issueId;
+}
+/**
+ * Narrator line: prefer the latest progress signal summary, fall back to the
+ * liveness summary, then to the bare status. Mirrors the design's
+ * `latest_update.summary / liveness.summary` rule.
+ */
+function deriveNarrator(input, workflowStatus) {
+    const latest = input.latest_update?.summary?.trim();
+    if (latest)
+        return latest;
+    const liveness = input.liveness?.summary?.trim();
+    if (liveness)
+        return liveness;
+    return `review ${workflowStatus}`;
+}
+/**
+ * Pure projection: {@link ReviewStatus} → {@link TreeViewModel}.
+ *
+ * `sessionRoot` is threaded explicitly (the caller already knows it) so the view
+ * model header is independent of how the status was fetched.
+ */
+export function reviewStatusToTreeViewModel(status, sessionRoot) {
+    const input = readProgressPresentationInput(status);
+    const workflowStatus = deriveWorkflowStatus(status.status);
+    // Consume only real progress-step ids: a prepared session fills
+    // `completed_steps` with preparation-artifact keys (interpretation/binding/
+    // execution_plan), a different vocabulary, which must not be matched against
+    // (or mistaken for) progress-step ids during phase rollup.
+    const completedStepIds = new Set((input.progress?.completed_steps ?? []).filter((id) => VALID_PROGRESS_STEP_IDS.has(id)));
+    const phases = derivePhases(status, completedStepIds, input.progress?.current_step ?? null, workflowStatus);
+    return {
+        pipeline: "review",
+        sessionId: status.sessionId,
+        sessionRoot,
+        status: workflowStatus,
+        narrator: deriveNarrator(input, workflowStatus),
+        liveness: {
+            state: input.liveness?.state ?? "unknown",
+            secondsSinceSignal: input.liveness?.seconds_since_last_observed_artifact ?? null,
+            pollMs: input.liveness?.poll_after_seconds == null
+                ? null
+                : input.liveness.poll_after_seconds * 1000,
+        },
+        phases,
+        summary: { findings: deriveFindings(input.result_classification_summary) },
+        runControl: deriveRunControl(status.runControl),
+    };
+}

package/dist/tui/view-model/tree-view-model.js

@@ -0,0 +1,19 @@
+/**
+ * Pipeline-agnostic view model rendered by the `onto watch` HUD.
+ *
+ * review and reconstruct expose progress in different shapes (review = per-UNIT
+ * live signal; reconstruct = per-STAGE state + owner + domain counts). The
+ * review/reconstruct adapters normalize both into this single shape, so the Ink
+ * HUD never branches on pipeline. This is a pure derived VIEW — it carries no
+ * authority and is never persisted.
+ */
+/**
+ * True when the workflow has reached a terminal state (stop polling). `halted`
+ * is terminal for the watch loop too: it sits paused awaiting an explicit
+ * operator continuation that may be a long way off, so the live loop stops
+ * rather than re-reading an unchanging projection every interval. The operator
+ * re-engages with [r]efresh after continuing (consistent with completed/failed).
+ */
+export function isTerminalStatus(status) {
+    return status === "completed" || status === "failed" || status === "halted";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onto-mcp",
-  "version": "0.4.11",
+  "version": "0.4.13",
   "description": "MCP-native ontology review runtime with context-isolated lenses and controlled deliberation",
   "homepage": "https://github.com/kangminlee-maker/onto-mcp#readme",
   "bugs": {
@@ -49,22 +49,39 @@
     "check:invariant-change": "tsx scripts/check-invariant-change-marker.ts",
     "check:invariant-drift": "tsx scripts/check-invariant-drift.ts",
     "check:supported-models": "tsx scripts/check-supported-models.ts",
+    "check:prompt-projection-parity": "tsx scripts/check-prompt-projection-parity.ts",
+    "check:final-output-sections-parity": "tsx scripts/check-final-output-sections-parity.ts",
+    "check:obligation-coverage": "tsx scripts/check-obligation-coverage.ts",
+    "check:dispatch-fallback-package-parity": "tsx scripts/check-dispatch-fallback-package-parity.ts",
+    "check:graceful-signal-rethrow": "tsx scripts/check-graceful-signal-rethrow.ts",
     "test": "npm run test:e2e",
+    "test:vitest": "vitest run",
     "test:review:live": "npm run build:ts-core && tsx scripts/review-mcp-live-e2e.ts",
     "test:review:live:cli": "npm run build:ts-core && tsx scripts/review-live-e2e.ts",
+    "test:reconstruct:dispatch-fallback:live": "node --env-file=.env --import tsx scripts/reconstruct-dispatch-fallback-live-e2e.mts",
+    "test:reconstruct:output-headroom:live": "node --env-file=.env --import tsx scripts/reconstruct-output-headroom-live-e2e.mts",
     "benchmark:review:pipeline": "tsx scripts/review-pipeline-benchmark.ts",
     "benchmark:reconstruct:pipeline": "tsx scripts/reconstruct-pipeline-benchmark.ts",
+    "calibration:effort:report": "tsx scripts/effort-calibration-report.ts",
     "migrate:reconstruct-artifact-fields": "tsx scripts/migrate-reconstruct-artifact-fields.ts",
     "test:e2e": "npm run build:ts-core && tsx scripts/review-mcp-live-e2e.ts"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.99.0",
-    "openai": "^6.33.0",
+    "@anthropic-ai/sdk": "0.99.0",
+    "fflate": "^0.8.3",
+    "ink": "^5.2.1",
+    "openai": "6.39.0",
+    "proper-lockfile": "^4.1.2",
+    "react": "^18.3.1",
+    "saxes": "^6.0.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/react": "^18.3.31",
+    "ink-testing-library": "^4.0.0",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"

package/settings.example.json

@@ -47,6 +47,19 @@
 
       # actors는 review 안에서 역할별로 실제 모델 설정을 소유합니다.
       # 즉 teamlead, lens, synthesize를 서로 독립적으로 바꿀 수 있습니다.
+      #
+      # ── provider 전환 ───────────────────────────────────────────────
+      # 손으로 고치는 대신 `onto configure-provider`가 아래 actor 블록을 검증 후
+      # 기록합니다(units 등 다른 설정은 보존). 예:
+      #   onto configure-provider --provider openai    --model gpt-5.5         --auth oauth --effort medium --service-tier fast
+      #   onto configure-provider --provider anthropic --model claude-opus-4-8 --auth oauth --effort high
+      # anthropic(Claude Code)로 손수 바꿀 때: 각 llm에서 provider를 "anthropic",
+      # model을 "claude-opus-4-8"로 바꾸고 "service_tier" 줄을 삭제합니다
+      # (service_tier는 openai+oauth 전용 — anthropic에 주면 거부됨).
+      # configure-provider는 actor만 기록하므로, 아래 units[].llm.model도 같은
+      # model로 바꾸거나 그 "model" 키를 지워 actor 값을 상속하게 하세요.
+      # 지원 model id: .onto/authority/supported-models.yaml
+      # ────────────────────────────────────────────────────────────────
       "actors": {
         # teamlead는 review 전체 진행과 숙의 조율을 담당합니다.
         "teamlead": {
@@ -60,7 +73,7 @@
             # provider는 사용할 모델 제공자입니다.
             "provider": "openai",
             # model은 사용할 모델 이름입니다.
-            "model": "gpt-5.5",
+            "model": "gpt-5.6-sol",
             # effort는 추론 강도입니다. 보통 medium이면 충분합니다.
             "effort": "medium",
             # service_tier는 Codex OAuth 경로에서 사용할 응답 속도 계층입니다.
@@ -80,7 +93,7 @@
             # provider는 사용할 모델 제공자입니다.
             "provider": "openai",
             # model은 사용할 모델 이름입니다.
-            "model": "gpt-5.5",
+            "model": "gpt-5.6-sol",
             # effort는 추론 강도입니다. 보통 medium이면 충분합니다.
             "effort": "medium",
             # service_tier는 Codex OAuth 경로에서 사용할 응답 속도 계층입니다.
@@ -100,7 +113,7 @@
             # provider는 사용할 모델 제공자입니다.
             "provider": "openai",
             # model은 사용할 모델 이름입니다.
-            "model": "gpt-5.5",
+            "model": "gpt-5.6-sol",
             # effort는 추론 강도입니다. xhigh는 더 깊게 검토하지만 비용과 시간이 늘 수 있습니다.
             "effort": "xhigh",
             # service_tier는 Codex OAuth 경로에서 사용할 응답 속도 계층입니다.
@@ -120,11 +133,11 @@
       # max_tokens/tool_mode은 direct_call/inline HTTP executor에서만 강제 가능합니다.
       # 기본 Codex OAuth worker 경로는 해당 knob를 강제할 수 없으므로 설정 시 fail-loud합니다.
       "units": {
-        # lens는 9개 관점별 독립 검토입니다. 아래 값들은 시작 기준 예시입니다.
-        # 실제 튜닝은 benchmark:review:pipeline의 unit-sweep 결과를 보고 조정하세요.
+        # lens는 9개 관점별 독립 검토입니다. 아래 값들은 decision-grade unit-sweep 결과입니다.
+        # 기준: development-records/benchmark/review-unit-effort-all-units-low-medium-high-decision-rerun2-20260610-winner-selection-merged.json
         "lens": {
           "llm": {
-            "model": "gpt-5.5",
+            "model": "gpt-5.6-sol",
             "effort": "medium"
           },
           "timeout_ms": 240000,
@@ -134,7 +147,7 @@
         },
         "finding_ledger": {
           "llm": {
-            "model": "gpt-5.5",
+            "model": "gpt-5.6-sol",
             "effort": "medium"
           },
           "timeout_ms": 240000,
@@ -144,7 +157,7 @@
         },
         "finding_relation_graph": {
           "llm": {
-            "model": "gpt-5.5",
+            "model": "gpt-5.6-sol",
             "effort": "medium"
           },
           "timeout_ms": 240000,
@@ -154,7 +167,7 @@
         },
         "issue_ledger": {
           "llm": {
-            "model": "gpt-5.5",
+            "model": "gpt-5.6-sol",
             "effort": "medium"
           },
           "timeout_ms": 240000,
@@ -164,7 +177,7 @@
         },
         "deliberation_plan": {
           "llm": {
-            "model": "gpt-5.5",
+            "model": "gpt-5.6-sol",
             "effort": "medium"
           },
           "timeout_ms": 240000,
@@ -174,7 +187,7 @@
         },
         "problem_framing": {
           "llm": {
-            "model": "gpt-5.5",
+            "model": "gpt-5.6-sol",
             "effort": "medium"
           },
           "timeout_ms": 240000,
@@ -191,7 +204,7 @@
 
         "issue_stance_response": {
           "llm": {
-            "model": "gpt-5.5",
+            "model": "gpt-5.6-sol",
             "effort": "medium"
           },
           "timeout_ms": 180000,
@@ -201,7 +214,7 @@
         },
         "deliberation_response": {
           "llm": {
-            "model": "gpt-5.5",
+            "model": "gpt-5.6-sol",
             "effort": "medium"
           },
           "timeout_ms": 180000,
@@ -211,8 +224,8 @@
         },
         "deliberation_resolution": {
           "llm": {
-            "model": "gpt-5.5",
-            "effort": "medium"
+            "model": "gpt-5.6-sol",
+            "effort": "low"
           },
           "timeout_ms": 240000,
           "max_retries": 2,
@@ -221,7 +234,7 @@
         },
         "synthesis_response": {
           "llm": {
-            "model": "gpt-5.5",
+            "model": "gpt-5.6-sol",
             "effort": "medium"
           },
           "timeout_ms": 180000,
@@ -231,5 +244,53 @@
         }
       }
     }
+  },
+
+  # reconstruct의 breaker-trip provider fallback은 기본적으로 꺼져 있습니다.
+  # 활성화할 때는 enabled만 바꾸지 말고 strict enabled 형식의 trigger/limit/llm
+  # 필드를 모두 명시해야 합니다. api_key 값 자체는 파일에 쓰지 않습니다.
+  # enabled 형식:
+  # "dispatch_fallback": {
+  #   "enabled": true,
+  #   "trigger": "rate_limit",
+  #   "max_fallback_passes": 1,
+  #   "per_dispatch_max_provider_attempts": 1,
+  #   "systemic_failure_threshold": 1,
+  #   "llm": {
+  #     "provider": "anthropic", "auth": "api_key",
+  #     "model": "<supported-model>", "effort": "medium",
+  #     "api_key_env": "ANTHROPIC_API_KEY"
+  #   }
+  # }
+  "reconstruct": {
+    "execution": {
+      # reconstruct actor도 역할별 독립 설정을 사용합니다.
+      # semantic_author를 openai + api_key direct API 경로로 명시 전환한 경우에만
+      # actor의 llm sibling인 llm_runtime.openai_responses_output_headroom_tokens를
+      # 양의 정수로 추가할 수 있습니다. 생략하면 기존 stage output ceiling을 그대로 씁니다.
+      "actors": {
+        "semantic_author": {
+          "llm": {
+            "auth": "oauth",
+            "provider": "openai",
+            "model": "gpt-5.5",
+            "effort": "medium",
+            "service_tier": "fast"
+          }
+        },
+        "confirmation_provider": {
+          "llm": {
+            "auth": "oauth",
+            "provider": "openai",
+            "model": "gpt-5.5",
+            "effort": "medium",
+            "service_tier": "fast"
+          }
+        }
+      },
+      "dispatch_fallback": {
+        "enabled": false
+      }
+    }
   }
 }