feat(reviewer): extract shared noema-core package (ADR-0014)

.github/workflows/central-review.yml

@@ -429,7 +429,7 @@ jobs:
       - name: Run independent PydanticAI review and publish current-head verdict
         env:
           GH_TOKEN: ${{ steps.noema_write_app.outputs.token }}
-          PYTHONPATH: ${{ github.workspace }}/reviewer
+          PYTHONPATH: ${{ github.workspace }}/reviewer:${{ github.workspace }}/packages/noema-core/src
           NOEMA_REVIEW_TOKEN_SOURCE: noema-github-app
           NOEMA_LLM_API_URL: ${{ vars.NOEMA_LLM_API_URL }}
           NOEMA_LLM_MODEL: ${{ vars.NOEMA_LLM_MODEL }}

.github/workflows/reviewer-ci.yml

@@ -20,6 +20,7 @@ jobs:
     timeout-minutes: 30
     env:
       NOEMA_CODEGRAPH_SANDBOX_SOURCE_IMAGE: gcr.io/distroless/java-base-debian13:nonroot
+      PYTHONPATH: ${{ github.workspace }}/reviewer:${{ github.workspace }}/packages/noema-core/src
     defaults:
       run:
         working-directory: reviewer
@@ -50,12 +51,98 @@ jobs:
       - name: install (hash-pinned dependencies)
         run: pip install --require-hashes --no-deps -r requirements-ci-hashes.txt
 
+      - name: test noema-core (100% line+branch coverage gate)
+        working-directory: packages/noema-core
+        run: python -m pytest
+
+      - name: docstring coverage noema-core (100% gate)
+        working-directory: packages/noema-core
+        run: python -m interrogate -c pyproject.toml src/noema_core
+
       - name: test (100% line+branch coverage gate)
         run: python -m pytest
 
       - name: docstring coverage (100% gate)
         run: python -m interrogate -c pyproject.toml noema_reviewer
 
+      - name: smoke-test installed reviewer wheel and sdist-to-wheel path
+        run: |
+          set -euo pipefail
+          wheel_dir="$RUNNER_TEMP/noema-reviewer-wheel"
+          sdist_dir="$RUNNER_TEMP/noema-reviewer-sdist"
+          sdist_wheel_dir="$RUNNER_TEMP/noema-reviewer-sdist-wheel"
+          direct_venv="$RUNNER_TEMP/noema-reviewer-install-smoke"
+          sdist_venv="$RUNNER_TEMP/noema-reviewer-sdist-install-smoke"
+          mkdir -p "$wheel_dir" "$sdist_dir" "$sdist_wheel_dir"
+
+          python -m pip wheel . --no-deps --no-build-isolation --wheel-dir "$wheel_dir"
+          direct_wheel="$(find "$wheel_dir" -maxdepth 1 -type f -name 'noema_reviewer-*.whl' -print -quit)"
+          test -n "$direct_wheel"
+
+          SDIST_DIR="$sdist_dir" SDIST_NAME_FILE="$RUNNER_TEMP/noema-reviewer-sdist-name" python - <<'PY'
+          import os
+          from pathlib import Path
+          from build_backend import build_sdist
+
+          sdist_name = build_sdist(os.environ["SDIST_DIR"])
+          Path(os.environ["SDIST_NAME_FILE"]).write_text(sdist_name, encoding="utf-8")
+          PY
+          sdist="$sdist_dir/$(cat "$RUNNER_TEMP/noema-reviewer-sdist-name")"
+          test -f "$sdist"
+          python -m pip wheel "$sdist" --no-deps --no-build-isolation --wheel-dir "$sdist_wheel_dir"
+          sdist_wheel="$(find "$sdist_wheel_dir" -maxdepth 1 -type f -name 'noema_reviewer-*.whl' -print -quit)"
+          test -n "$sdist_wheel"
+
+          for contract in direct sdist; do
+            if [ "$contract" = direct ]; then
+              wheel="$direct_wheel"
+              venv_dir="$direct_venv"
+            else
+              wheel="$sdist_wheel"
+              venv_dir="$sdist_venv"
+            fi
+            python -m venv --system-site-packages "$venv_dir"
+            (
+              cd "$RUNNER_TEMP"
+              PYTHONPATH='' "$venv_dir/bin/python" -m pip install --no-deps "$wheel"
+              PYTHONPATH='' "$venv_dir/bin/python" - <<'PY'
+          import hashlib
+          import os
+          from pathlib import Path
+
+          import noema_core
+          import noema_core.agent
+          import noema_reviewer
+          from noema_reviewer.cli import parse_args
+
+          canonical_agent = Path(os.environ["GITHUB_WORKSPACE"]) / "packages" / "noema-core" / "src" / "noema_core" / "agent.py"
+          installed_agent = Path(noema_core.agent.__file__)
+          assert hashlib.sha256(installed_agent.read_bytes()).digest() == hashlib.sha256(canonical_agent.read_bytes()).digest()
+          assert noema_core.NOEMA_PERSONA
+          assert noema_reviewer.build_agent is not None
+          assert parse_args([]).repo == ""
+          PY
+            )
+          done
+
+      - name: smoke-test isolated editable reviewer with locked runtime dependencies
+        run: |
+          set -euo pipefail
+          editable_venv="$RUNNER_TEMP/noema-reviewer-editable-smoke"
+          python -m venv "$editable_venv"
+          "$editable_venv/bin/python" -m pip install --require-hashes --no-deps -r requirements-ci-hashes.txt
+          "$editable_venv/bin/python" -m pip install --no-deps -e .
+          (
+            cd "$RUNNER_TEMP"
+            PYTHONPATH='' "$editable_venv/bin/python" - <<'PY'
+          import noema_core
+          import noema_reviewer
+
+          assert noema_core.build_agent is not None
+          assert noema_reviewer.build_agent is not None
+          PY
+          )
+
       - name: install lock-pinned CodeGraph tooling for sandbox smoke test
         env:
           NPM_CONFIG_IGNORE_SCRIPTS: "true"
@@ -98,7 +185,7 @@ jobs:
           source_root="$RUNNER_TEMP/noema-codegraph-smoke"
           mkdir -p "$source_root"
           printf 'export const commercialReadiness = true;\n' >"$source_root/example.ts"
-          PYTHONPATH=. python - <<'PY'
+          python - <<'PY'
           import os
           from noema_reviewer.sandbox import DockerCodeGraphRunner
 

.gitignore

@@ -11,3 +11,4 @@ exchange-30d.ndjson
 exchange-30d.ndjson.provenance.json
 noema-kpi-evidence.json
 noema-smoke-evidence.json
+reviewer/_build_include/

CHANGELOG.md

@@ -1,6 +1,7 @@
 # Changelog
 
 ## Unreleased
+- `noema-core` provider-neutral Shared Kernel을 추가하여 이미 해석된 PydanticAI `Model`과 역할별 prompt/schema만 받아 Agent를 구성한다. 문자열 model identifier와 provider discovery·credential·routing·retry·failover는 Shared Kernel 밖에 두고 `Agent(..., retries=0)`으로 repository-local model-attempt authority를 만들지 않는다. Reviewer wheel·sdist·editable 설치는 canonical `packages/noema-core` source를 포함하거나 참조하며 별도 100% coverage·docstring과 clean install smoke로 검증한다. 외부 소비는 immutable versioned publication·exact source identity·SBOM/provenance·licensing/NOTICE·compatibility/rollback evidence 전에는 허용하지 않는다.
 - Noema reviewer의 strict changed-file evidence를 historical 12-file prefix에서 canonical 80-file CodeGraph scope와 일치시켰다. 13–80 file PR은 선택된 모든 current-head file context를 유지하고 81개 이상은 기존처럼 실패-폐쇄하며, local CodeGraph fallback의 `HOME`·`TEMP`·`TMP`·`TMPDIR`은 ambient host path를 상속하지 않고 실행마다 새 private temporary directory로 격리한다.
 - Workflow / Task Execution은 untrusted DAG를 execution/plan identity에 결합한 detached immutable snapshot으로 승인하고, validated array bounds 안에서만 task/dependency/state evidence를 읽는다. runnable 선택은 cross-execution·foreign·duplicate·non-canonical evidence, admitted concurrency를 초과한 running state, 성공하지 않은 prerequisite 뒤에 존재하는 causally impossible executed state를 실패-폐쇄하며, 선택 결과는 reservation이나 side-effect authority가 아닌 후보임을 명시한다. Agent Runtime lifecycle·State & Checkpoint·Workflow admission은 null·throwing accessor·revoked proxy 같은 malformed runtime input의 임의 JavaScript 예외를 각 bounded-context domain error로 정규화한다.
 - State & Checkpoint admission은 accepted/replay 결과와 내부 checkpoint를 모두 caller-owned alias에서 분리한 frozen snapshot으로 반환한다. TypeScript `readonly`만으로는 막을 수 없는 JavaScript 런타임 alias mutation이 승인된 checkpoint authority나 `accepted`/`replay` 분류를 사후 변경하지 못하도록 실패-폐쇄한다.

docs/adr/0014-shared-noema-core-package.md

@@ -0,0 +1,100 @@
+# ADR-0014: Minimal `noema-core` Shared Kernel for Agent construction
+
+- **Status:** Proposed
+- **Decision owner:** Noema repository governance
+- **Scope:** `ContextualWisdomLab/noema` reviewer self-consumption and future versioned consumers
+
+## Problem
+
+Noema has multiple bounded-context consumers that need the same PydanticAI `Agent(...)` construction semantics, but those consumers do not share domain authority. Repeating the framework construction call in each consumer creates drift; centralizing model discovery, provider SDKs, credentials, fallback, retry policy, verdict schemas, tools, tenant state, or security policy would instead violate the repository's DDD boundary and duplicate canonical owners.
+
+The previous branch-local ADR used number `0012`, which now belongs on protected `main` to the runtime bounded-context decision. ADR identity is immutable repository architecture authority, so this decision is renumbered to `0014` rather than retaining two different ADR-0012 documents.
+
+## Constraints
+
+- `contextual-orchestrator` owns provider/model discovery, routing, test-time compute, provider/model retry and failover, provider credentials and provider-specific transport policy.
+- Noema owns Agent Runtime and its bounded contexts, not foreign product truth.
+- Reviewer verdict schema, deterministic gates, GitHub evidence policy and reviewer publication remain reviewer-owned.
+- Tenant/application tool authority and domain state stay in their owning product.
+- Security isolation, quarantine and outbound-policy authority stay with their canonical owners.
+- Mutable branch refs and copied source are not acceptable cross-repository dependencies.
+- External adoption requires an immutable versioned publication with exact source identity and compatibility evidence.
+
+## Alternatives
+
+### A. Duplicate the construction in every consumer
+
+Rejected. It preserves local autonomy but guarantees repeated framework wiring and version drift without adding a useful bounded-context distinction.
+
+### B. Put provider discovery, retry or transport in `noema-core`
+
+Rejected. That would recreate `contextual-orchestrator` policy inside Noema and would let a Shared Kernel become an ambient provider/model-attempt authority boundary.
+
+### C. Build an always-on Noema service for every consumer
+
+Rejected for this phase. A service would add deployment, network, authorization and recovery semantics that are not required to remove the verified same-language construction duplication. Cross-language consumers can be handled through released service/API contracts when a real caller requires them.
+
+### D. Minimal package with caller-supplied model
+
+Chosen. `packages/noema-core` owns only a role-neutral Noema persona fragment and a factory that accepts an already-constructed PydanticAI `Model` and calls `Agent(...)` with caller-owned prompt, output and deps types. The factory fixes PydanticAI model-attempt retries to zero instead of exposing a reusable retry knob; orchestration-level retry/failover remains with `contextual-orchestrator`.
+
+## Decision
+
+Create `packages/noema-core` as a minimal Shared Kernel with:
+
+- `NOEMA_PERSONA = "You are Noema"` as a role-neutral identity prefix;
+- `build_agent(model, *, system_prompt, output_type=str, deps_type=None)`;
+- rejection of string model identifiers so PydanticAI's implicit provider/model inference cannot move discovery into the Shared Kernel;
+- no caller-visible `retries` parameter and `Agent(..., retries=0)` at this boundary so the Shared Kernel cannot silently create additional model attempts outside the orchestrator contract.
+
+`noema-core` deliberately does **not** own:
+
+- provider SDK construction or endpoint selection;
+- credentials, key discovery, model groups, retries or fallback;
+- reviewer verdicts, gates or merge authority;
+- tool/dependency authorization;
+- tenant isolation, domain persistence or foreign truth;
+- quarantine, egress or malware/security verdict authority.
+
+The current PR's only production consumer is `reviewer/noema_reviewer`. Reviewer packaging stages the canonical `packages/noema-core/src/noema_core` source into wheel/sdist builds so the installed reviewer contains the exact shared module without copying a second source tree. Editable installs and CI use the same canonical path. This is a transitional monorepo packaging arrangement, not permission for external repositories to consume the mutable branch.
+
+## Verification contract
+
+Before this decision can become `Accepted`, the exact candidate head must prove:
+
+1. `packages/noema-core` line and branch coverage are 100% and public docstring coverage is 100%.
+2. The reviewer retains its existing coverage/docstring gates and behavior.
+3. Installed reviewer wheel and sdist-to-wheel smoke tests import both `noema_reviewer` and `noema_core` outside the checkout and prove the installed shared `agent.py` bytes match the canonical source.
+4. Evidence-only reviewer imports remain lazy and do not require model construction.
+5. String model identifiers fail closed at the Shared Kernel boundary.
+6. `build_agent` exposes no retry-policy argument and constructs the PydanticAI agent with model-attempt retries disabled; provider/model retry and failover remain contextual-orchestrator authority.
+7. Central review execution receives the canonical package path without moving provider routing authority into Noema.
+8. No cross-repository consumer adopts `noema-core` until immutable publication exists.
+
+## Publication boundary
+
+A merge of this PR establishes protected source, not an external dependency. External consumption requires the repository's selected immutable publication mechanism to provide all applicable evidence together:
+
+- semantic version and immutable source commit;
+- artifact digest/integrity;
+- package/install smoke tests;
+- SBOM and provenance;
+- licensing/NOTICE compatibility;
+- compatibility/migration and rollback guidance.
+
+After such a release exists, consumers must pin the released version through their own ACL/adapter and regenerate their exact-head acceptance evidence. A mutable Git branch, local path, copied module, or open PR head is never the production dependency.
+
+## Consequences
+
+The shared surface stays intentionally small, so framework construction drift is removed without turning Noema into an LLM gateway or a domain super-service. The cost is a transitional reviewer build backend until `noema-core` has its own immutable package publication. That transitional backend must remain bounded, deterministic and covered by installed-artifact tests.
+
+Removing the retry argument is intentionally restrictive. A consumer that needs a different attempt policy must not add a local convenience knob to the Shared Kernel; it must use the released contextual-orchestrator contract or make a separately reviewed bounded-context decision that does not duplicate provider/model retry authority.
+
+A future need for cross-language access is a separate architecture decision. It should begin from a real consumer and released contract rather than expanding this package pre-emptively.
+
+## Follow-up
+
+- Merge the reviewer self-consumption only after current-head CI, security, reviewer, package and provenance gates pass.
+- Publish `noema-core` through the repository-approved immutable mechanism when release evidence is ready.
+- Replace transitional monorepo bundling with a normal released dependency after publication.
+- Update any future consumer only after verifying its canonical owner boundary and exact released artifact identity.

docs/adr/README.md

@@ -16,6 +16,7 @@ ADR은 **왜 이 구조를 선택했는지**를 기록합니다. 구현 상태
 | [0010](./0010-private-target-review-auth.md) | Proposed | private review target의 첫 live PR lookup부터 single-repository Noema App token을 사용하고 workflow `GITHUB_TOKEN` cross-repository fallback을 금지한다. |
 | [0011](./0011-independent-reviewer-governance.md) | Proposed | qualifying formal approval의 eligibility·exact-head·staleness를 검증하고 check/status/scanner/model evidence가 approval을 대체하지 못하게 한다. |
 | [0012](./0012-runtime-orchestration-bounded-contexts.md) | Proposed | Agent Runtime, Workflow / Task Execution, Tool / Capability, State / Checkpoint, isolation, policy, observability, recovery의 소유권을 분리하고 provider routing·foreign truth·cross-service SQL을 Noema 경계 밖에 둔다. |
+| [0014](./0014-shared-noema-core-package.md) | Proposed | role-neutral PydanticAI `Agent(...)` construction만 `packages/noema-core` Shared Kernel로 추출하고 provider routing·credential policy·verdict·tool/deps·tenant truth는 canonical owner에 남긴다. |
 
 ## ADR lifecycle
 

packages/noema-core/.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+.coverage
+.pytest_cache/
+*.egg-info/

packages/noema-core/README.md

@@ -0,0 +1,55 @@
+# noema-core
+
+Provider-neutral PydanticAI `Agent` construction shared by Noema's per-context
+consumers. See [`docs/adr/0014-shared-noema-core-package.md`](../../docs/adr/0014-shared-noema-core-package.md)
+for the decision and its scope boundary.
+
+## What this package is
+
+One function and one role-neutral identity fragment shared without moving
+provider or bounded-context authority into Noema:
+
+- `build_agent(model, *, system_prompt, output_type=str, deps_type=None, retries=3) -> Agent`
+  constructs an agent around a caller-supplied, already constructed PydanticAI
+  `Model`. String model names are rejected so provider/model discovery cannot
+  occur inside the Shared Kernel.
+- `NOEMA_PERSONA` is exactly `"You are Noema"`. Consumers compose that stable
+  identity with their own precise role, organization context, evidence rules,
+  tool authority and output contract; the Shared Kernel does not assign a
+  generic role that could weaken a specialized reviewer or runtime agent.
+
+The injected model is deliberate. `noema-core` does not construct `AsyncOpenAI`,
+`OpenAIChatModel`, `OpenAIProvider`, provider credentials, model discovery,
+routing or failover. A consuming bounded context may own a transport adapter to
+the published `contextual-orchestrator` interface, but that adapter does not
+become Shared Kernel authority.
+
+## What this package explicitly is not
+
+It does not own a verdict/output schema, tool/deps machinery, credential
+resolution or validation policy, provider SDK, routing policy, provider
+fallback, or tenant isolation. Those stay with their canonical owners.
+
+## Status
+
+Self-consumption only: `reviewer/noema_reviewer` is the sole consumer today.
+`noema-core` is not yet published to an immutable package index, so external
+consumers must not pin a mutable branch or copy this source. During this
+transition the `noema-reviewer` distribution includes `noema_core` from this
+single canonical source path through the custom packaging backend. Wheel and
+sdist builds stage a bounded snapshot; editable installs keep an ignored
+canonical-source view so their package mapping remains valid after the PEP 660
+hook completes. Required `reviewer-ci` runs this package's 100% line/branch and
+docstring gates and validates installed distributions outside the checkout.
+
+Publishing `noema-core` through the repository's selected immutable package
+mechanism and moving consumers to a normal versioned dependency are tracked as
+follow-ups in the ADR.
+
+## Develop
+
+```bash
+pip install -e .
+python -m pytest             # 100% line+branch coverage gate
+python -m interrogate -c pyproject.toml src/noema_core   # 100% docstring gate
+```