atomadic-forge 0.14.0__tar.gz → 0.14.1__tar.gz

{atomadic_forge-0.14.0 → atomadic_forge-0.14.1}/.github/workflows/customer-refactor.yml

@@ -92,7 +92,7 @@ jobs:
           echo "Customer: $CUSTOMER_EMAIL"
 
       - name: Set up Python 3.12
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: "3.12"
 

{atomadic_forge-0.14.0 → atomadic_forge-0.14.1}/CHANGELOG.md

@@ -1,5 +1,92 @@
 # Changelog
 
+## Unreleased — 2026-05-06 synergy signal and version repair
+
+Forge-on-Forge evolution pass: `synergy_scan` now distinguishes
+stdout-only `--json` switches from real artifact-writing path options
+such as `--save`, `--out`, and `--report`. This removes false
+JSON-handoff candidates like command groups that print JSON but do not
+write an artifact file. The synergy adapter renderer also targets the
+current `atomadic_forge.a4_sy_orchestration.cli` module instead of the
+retired unified CLI path.
+
+MCP doctor exposed a release drift in editable/worktree setups where
+installed package metadata could still report `0.14.0a10` after the
+checkout's `pyproject.toml` had advanced to `0.14.0`. Source checkouts
+now prefer their local `pyproject.toml`; installed wheels continue to
+fall back to package metadata.
+
+Validation:
+
+```
+forge emergent scan --src-root src --package atomadic_forge --top-n 10 --json
+forge emergent_swarm -r ... --json
+forge certify . --fail-under 100 --json
+```
+
+Also pending in this slot:
+
+- **`forge handoff create / list / show`** — structured agent-to-agent
+  session transfer at `.atomadic-forge/handoffs/<HOFF-id>.json`. CLI verb
+  + MCP tools `handoff_create` and `handoff_list` (surface 61 → 63).
+  Schema `atomadic-forge.handoff/v1` with `axiom_guard_status`
+  PASS|QUARANTINE so the next agent reads the trust verdict before it
+  resumes work. +18 tests.
+- **AST-aware class classifier** — `body_extractor.detect_class_signals()`
+  returns `is_protocol`, `is_frozen_dataclass`, `all_static_methods`,
+  `has_cached_property` alongside the existing self-assign signals.
+  `classify_tier()` honors them BEFORE name heuristics: `Protocol → a0`,
+  `@dataclass(frozen=True) → a1`, all-`@staticmethod` → a1,
+  `@cached_property → a2`. New `classify_tier_with_confidence()`
+  returns `{tier, confidence, reasons}` for callers that want to route
+  low-confidence guesses to manual review. +17 tests.
+- **`wire_check` edge cases** — `if TYPE_CHECKING:` guarded imports are
+  no longer flagged as runtime violations; surfaced under
+  `type_only_imports` for visibility. `importlib.import_module(...)`
+  calls land in `dynamic_import_warnings` (string-literal modules
+  resolved; non-literals marked `<dynamic>`). `from .X import *` always
+  surfaces in `star_import_warnings`. New `--strict-cycles` opt-in flag
+  detects same-tier file-pair cycles, reported in `same_tier_cycles`.
+  Backward compatible: existing v1 schema fields untouched. +10 tests.
+- **First-pass tier discipline block** — `system_prompt()` (Python
+  variant) gains a section that mirrors the new AST-classifier signals
+  so the LLM lands tiers right on the first emission rather than paying
+  a feedback round-trip. Calls out: Protocol→a0, frozen dataclass→a1,
+  all-static→a1, self-assign→a2, cached_property→a2, TYPE_CHECKING
+  permitted, dynamic/star warnings explained. +1 test.
+
+Cumulative: 1133 → 1177 tests, 61 → 63 MCP tools.
+
+## v0.14.0 — 2026-05-05 alpha-series finalization (PyPI release)
+
+**release_commit_ts:** 2026-05-06T04:02:23Z (ef37eca)
+
+The first non-prerelease in the v0.14.0 line. Drops the `aN` suffix
+after ten alpha iterations (`a1` through `a10`) and ships the
+cumulative surface to PyPI. `pip install atomadic-forge` now returns
+`0.14.0` (was `0.10.0` since 2025).
+
+Highlights (all already documented in their own alpha entries below):
+
+- Full hive sync pipeline (`hive_register / observe / propose / vote /
+  result / list / deactivate / watch / needs-vote / recap`) for
+  multi-agent consensus over append-only public artifacts.
+- AAAA-Nexus bridge: 7 LIVE primitives wired as MCP tools
+  (`nexus_identity_verify`, `nexus_federation_mint`,
+  `nexus_authorize_action`, `nexus_sys_trust_gate`,
+  `nexus_contract_verify`, `nexus_lineage_record`,
+  `nexus_ratchet_register`). Wisdom + consensus auto-mirror at
+  confidence ≥ 0.85.
+- Local relay daemon (`forge relay serve`) — Worker → local job
+  dispatch over signed JSON-RPC envelopes.
+- Surface artifact + drift CI gate (`surface.json` + `forge surface
+  emit/check/diff`).
+- Wisdom DB on the MCP surface + wisdom → recipe promotion.
+
+Surface at release: 61 MCP tools. Tests: 1131 passed, 2 skipped.
+README, contact email (`thomas@atomadic.tech`), and version display
+all reconciled with the live repo.
+
 ## v0.14.0a10 — 2026-05-06 forge hive recap (full lifecycle visualization)
 
 **release_commit_ts:** 2026-05-06T01:50:00Z

{atomadic_forge-0.14.0 → atomadic_forge-0.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.14.0
+Version: 0.14.1
 Summary: Atomadic Forge — absorb, enforce, emerge. Polyglot (Python · JavaScript/TypeScript · Swift · Kotlin · Go) architecture guardian for AI-generated code.
 Author: Atomadic
 License-Expression: BUSL-1.1
@@ -25,9 +25,9 @@ Requires-Dist: ruff>=0.4; extra == "dev"
 Requires-Dist: build<2,>=1; extra == "dev"
 Requires-Dist: twine<7,>=5; extra == "dev"
 Requires-Dist: tomli>=2; python_version < "3.11" and extra == "dev"
-Requires-Dist: cryptography<46,>=42; extra == "dev"
+Requires-Dist: cryptography<48,>=42; extra == "dev"
 Provides-Extra: signing
-Requires-Dist: cryptography<46,>=42; extra == "signing"
+Requires-Dist: cryptography<48,>=42; extra == "signing"
 Dynamic: license-file
 
 <p align="center">
@@ -283,7 +283,7 @@ generate).
 ```bash
 git clone https://github.com/atomadictech/atomadic-forge && cd atomadic-forge
 pip install -e ".[dev]"
-python -m pytest               # 1178 collected (1176 passed, 2 skipped)
+python -m pytest               # 1179 collected (1177 passed, 2 skipped)
 ```
 
 ## AI Agent integration (MCP)
@@ -594,7 +594,7 @@ Forge ships with named limits. No overpromise.
 | Product | What it is | Status |
 |---------|------------|--------|
 | **AAAA-Nexus** | Trust/safety/payments substrate for autonomous agents | Live at [atomadic.tech](https://atomadic.tech) |
-| **Atomadic Forge** | Absorb-and-emerge engine for developers (this repo) | **v0.14.0** — on PyPI, 1176 tests, 100/100, MCP server (63 tools local · 40 on Worker), four-agent hive primitives, AAAA-Nexus bridge |
+| **Atomadic Forge** | Absorb-and-emerge engine for developers (this repo) | **v0.14.0** — on PyPI, 1177 tests, 100/100, MCP server (63 tools local · 40 on Worker), four-agent hive primitives, AAAA-Nexus bridge, agent-to-agent handoffs |
 | **Atomadic Assistant** | Sovereign AI assistant with cognitive loop on Cloudflare | In development |
 
 ## Pricing
@@ -643,7 +643,7 @@ Apache 2.0.
 **Forge itself is monadic.** Every source file belongs to one tier. The repo is a worked example:
 
 ```bash
-python -m pytest                     # 1176 passed, 2 skipped
+python -m pytest                     # 1177 passed, 2 skipped
 forge doctor                         # Environment check
 forge wire src/atomadic_forge        # Scan for violations (PASS)
 forge certify . --fail-under 100     # Score and gate the repo (100/100)

{atomadic_forge-0.14.0 → atomadic_forge-0.14.1}/README.md

@@ -251,7 +251,7 @@ generate).
 ```bash
 git clone https://github.com/atomadictech/atomadic-forge && cd atomadic-forge
 pip install -e ".[dev]"
-python -m pytest               # 1178 collected (1176 passed, 2 skipped)
+python -m pytest               # 1179 collected (1177 passed, 2 skipped)
 ```
 
 ## AI Agent integration (MCP)
@@ -562,7 +562,7 @@ Forge ships with named limits. No overpromise.
 | Product | What it is | Status |
 |---------|------------|--------|
 | **AAAA-Nexus** | Trust/safety/payments substrate for autonomous agents | Live at [atomadic.tech](https://atomadic.tech) |
-| **Atomadic Forge** | Absorb-and-emerge engine for developers (this repo) | **v0.14.0** — on PyPI, 1176 tests, 100/100, MCP server (63 tools local · 40 on Worker), four-agent hive primitives, AAAA-Nexus bridge |
+| **Atomadic Forge** | Absorb-and-emerge engine for developers (this repo) | **v0.14.0** — on PyPI, 1177 tests, 100/100, MCP server (63 tools local · 40 on Worker), four-agent hive primitives, AAAA-Nexus bridge, agent-to-agent handoffs |
 | **Atomadic Assistant** | Sovereign AI assistant with cognitive loop on Cloudflare | In development |
 
 ## Pricing
@@ -611,7 +611,7 @@ Apache 2.0.
 **Forge itself is monadic.** Every source file belongs to one tier. The repo is a worked example:
 
 ```bash
-python -m pytest                     # 1176 passed, 2 skipped
+python -m pytest                     # 1177 passed, 2 skipped
 forge doctor                         # Environment check
 forge wire src/atomadic_forge        # Scan for violations (PASS)
 forge certify . --fail-under 100     # Score and gate the repo (100/100)

atomadic_forge-0.14.1/docs/handoffs/WORKER_AUTO_DEPLOY_2026-05-06.md

@@ -0,0 +1,184 @@
+# Forge Worker auto-deploy handoff
+
+> Doc/Orchestrator — 2026-05-06T05:22Z (T-9h to Boris demo)
+>
+> **Owner directive**: "Make sure the forge worker has the latest
+> version and we need to somehow automate the worker update whenever
+> we push a new version to github with the version tag.  So all users
+> who connect will always use the latest mcp and forge version."
+
+## Current state — and why "latest" never propagates
+
+| Surface | Version | Source |
+|---------|---------|--------|
+| `pip install atomadic-forge` | **`0.14.0`** | PyPI (auto-published from `atomadictech/atomadic-forge` on tag) |
+| `forge` CLI / local pip MCP | **`0.14.0`** | same |
+| `forge.atomadic.tech/mcp` Worker | **`0.10.0`** ← four minor versions behind | manual `wrangler deploy` |
+| Worker source | local files only at `C:\!!AtomadicStandard\atomadic-forge-cloudflare-workers\mcp\` | **NO git remote, NO CI** |
+
+Live evidence (2026-05-06T05:18Z):
+
+```bash
+$ curl -X POST https://forge.atomadic.tech/mcp \
+     -H "Content-Type: application/json" \
+     -H "X-API-Key: $FORGE_MASTER_API_KEY" \
+     --data '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"doctor","arguments":{}}}'
+
+# {"runtime": "cloudflare-worker", "worker_version": "0.10.0", ...}
+```
+
+## Why this is a Boris-demo P0
+
+Research agent caught it (`WIS-research-worker-version-drift`,
+`WIS-research-worker-cli-score-divergence` on `atomadic-forge`):
+
+- Worker v0.10.0 has the **Python-only tier classifier**.
+- Local CLI v0.14.0 has the **polyglot TS/JS/Python classifier**.
+- Same repo certified through Worker vs local CLI returns **different scores** (hono: Worker=30, CLI=55; atomadic-forge: Worker=80, CLI=100).
+- Atomadic's chat-led `FORGE_DEMO` action calls the **Worker** via `callForgeService`, so an autonomous chat-led demo will **not reproduce captured terminal numbers**.
+
+## Why the Worker can't auto-update today
+
+The Python repo `atomadictech/atomadic-forge` has the full release pipeline
+(GitHub Actions on tag → PyPI publish + GitHub Release).  But the **Worker
+source isn't there**.  It's in a sibling local directory that:
+
+1. has no `.git` folder
+2. is not in any GitHub repo
+3. has no `wrangler.toml [build]` triggered from CI
+4. was never linked to the Python release tag
+
+So pushing a new tag to `atomadic-forge` does nothing for the Worker.  No
+matter how many `v0.14.x` releases ship, `forge.atomadic.tech/mcp` keeps
+serving `0.10.0` until someone runs `wrangler deploy` manually.
+
+## The fix path (4 steps, all out of orchestrator scope)
+
+### Step 1 — get the Worker source onto GitHub
+
+Two options.  Both are dev/ops decisions for Thomas + Forge agent.
+
+**Option A: dedicated repo** (clean separation)
+
+```bash
+cd C:\!!AtomadicStandard\atomadic-forge-cloudflare-workers
+git init
+git add .
+git commit -m "initial: forge MCP Worker (was local-only)"
+gh repo create atomadictech/atomadic-forge-cloudflare-workers --public \
+    --description "Cloudflare Worker hosting forge.atomadic.tech/mcp"
+git push -u origin main
+```
+
+**Option B: subfolder of atomadic-forge** (shares CI + version)
+
+```bash
+cd C:\!!AtomadicStandard\atomadic-forge
+mkdir -p cloudflare-workers
+cp -r ../atomadic-forge-cloudflare-workers/mcp cloudflare-workers/mcp
+git add cloudflare-workers/
+git commit -m "feat(worker): import MCP Worker source for CI auto-deploy"
+git push origin main
+```
+
+**Doc/Orchestrator's recommendation: Option B.**  Reasons:
+
+- Worker version SHOULD track Python release version — they're tied conceptually.
+- The same release tag (`v0.14.0`) can fan out to PyPI AND wrangler deploy in one workflow.
+- Less repo-management overhead.
+- Forge agent already maintains the Python CI; adding wrangler is incremental.
+
+### Step 2 — add the auto-deploy workflow
+
+Create `.github/workflows/deploy-worker.yml`:
+
+```yaml
+name: Deploy Forge MCP Worker
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 20
+
+      - name: Sync Worker version with release tag
+        working-directory: cloudflare-workers/mcp
+        run: |
+          v="${GITHUB_REF_NAME#v}"
+          npm pkg set version="$v"
+          # Inline the version into the doctor response so the runtime
+          # reports it without a separate import.
+          sed -i "s/\"worker_version\": \"[^\"]*\"/\"worker_version\": \"$v\"/" src/a4_sy_orchestration/index.ts
+
+      - name: Install
+        working-directory: cloudflare-workers/mcp
+        run: npm ci
+
+      - name: Typecheck
+        working-directory: cloudflare-workers/mcp
+        run: npm run typecheck
+
+      - name: Deploy
+        working-directory: cloudflare-workers/mcp
+        env:
+          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+        run: npx wrangler deploy --var WORKER_VERSION:"${GITHUB_REF_NAME#v}"
+```
+
+### Step 3 — add Cloudflare secrets to the repo
+
+```bash
+gh secret set CLOUDFLARE_API_TOKEN --repo atomadictech/atomadic-forge
+gh secret set CLOUDFLARE_ACCOUNT_ID --repo atomadictech/atomadic-forge
+```
+
+(Token needs `Workers Scripts: Edit` + `Account: Read`.  Operator already
+has these in `.env`.)
+
+### Step 4 — port the v0.10.0 → v0.14.x deltas into the TS Worker
+
+This is the part that's **NOT free**.  The Worker is a TS port of the
+Python tier classifier; it lags the Python source.  v0.14.0's polyglot
+classifier (TS/JS/Python tier detection, score 55/100 on hono / atproto /
+fastapi / express) needs to be ported into `cloudflare-workers/mcp/src/`.
+
+Proposed scope split:
+
+- **Forge agent** writes the TS port of the polyglot classifier.
+- **Cognition agent** updates `callForgeService` to read the Worker's
+  reported `worker_version` and degrade gracefully if the Worker is older
+  than the local CLI.
+- **Doc agent** (this file) tracks the bump in the README + status report.
+
+## Interim mitigation for Boris demo (T-9h)
+
+Per `WIS-research-worker-explain-rescue` (committed 2026-05-06T04:46Z):
+
+- The Worker's `explain_repo` tool returns GitHub metadata + a basic
+  certify_score.  It IS demoable.
+- **Path**: chat-led demo skips `recon`/`certify`, uses `explain_repo`,
+  discloses **once** that this is the hosted lighter version.
+- Backup: terminal-led path (`run_demo_live.bat`) uses the local CLI
+  v0.14.0 directly — bulletproof reproduction of captured numbers.
+
+## Verdict
+
+**REFINE** — auto-deploy infrastructure does not exist; bringing the
+Worker to parity with the Python release is product/ops work, not
+orchestration.  Doc agent has documented the gap, the fix path, and
+the demo-time mitigation.  Action lies with Thomas (Option A vs B
+choice) and the Forge / Cognition agents (CI + classifier port).
+
+— Docs/Orchestrator
+  2026-05-06T05:22Z

{atomadic_forge-0.14.0 → atomadic_forge-0.14.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "atomadic-forge"
-version = "0.14.0"
+version = "0.14.1"
 description = "Atomadic Forge — absorb, enforce, emerge. Polyglot (Python · JavaScript/TypeScript · Swift · Kotlin · Go) architecture guardian for AI-generated code."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -38,10 +38,10 @@ dev = [
     "build>=1,<2",
     "twine>=5,<7",
     "tomli>=2; python_version<'3.11'",
-    "cryptography>=42,<46",
+    "cryptography>=42,<48",
 ]
 signing = [
-    "cryptography>=42,<46",
+    "cryptography>=42,<48",
 ]
 
 [project.scripts]

atomadic_forge-0.14.1/src/atomadic_forge/__init__.py

@@ -0,0 +1,58 @@
+"""Atomadic Forge — absorb, enforce, emerge.
+
+A monadic-architecture engine for absorbing Python or JavaScript /
+TypeScript repositories into a verified 5-tier layout, enforcing layered
+import discipline, and surfacing emergent compositions across the
+resulting catalog.
+
+Public version surface only — every symbol lives in its tier package and
+is re-exported lazily by the CLI.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def _parse_project_version(text: str) -> str | None:
+    try:
+        try:
+            import tomllib
+        except ModuleNotFoundError:  # pragma: no cover - Python 3.10
+            import tomli as tomllib  # type: ignore[no-redef]
+        data = tomllib.loads(text)
+        project = data.get("project", {})
+        if project.get("name") == "atomadic-forge":
+            version = project.get("version")
+            return version if isinstance(version, str) else None
+    except Exception:
+        return None
+    return None
+
+
+def _local_pyproject_version() -> str | None:
+    for parent in Path(__file__).resolve().parents:
+        pyproject = parent / "pyproject.toml"
+        if not pyproject.exists():
+            continue
+        version = _parse_project_version(pyproject.read_text(encoding="utf-8"))
+        if version:
+            return version
+    return None
+
+
+def _installed_version() -> str | None:
+    try:
+        from importlib.metadata import PackageNotFoundError as _PNF
+        from importlib.metadata import version as _pkg_version
+        try:
+            return _pkg_version("atomadic-forge")
+        except _PNF:
+            return None
+    except ImportError:  # pragma: no cover - Python < 3.8 path
+        return None
+
+
+# Source checkouts prefer their own pyproject.toml; installed wheels fall
+# back to package metadata because wheel installs do not ship pyproject.toml.
+__version__ = _local_pyproject_version() or _installed_version() or "0.0.0+dev"

atomadic_forge-0.14.1/src/atomadic_forge/a0_qk_constants/enhancement_proposal_constants.py

@@ -0,0 +1,44 @@
+"""Tier a0 — enhancement-proposal constants.
+
+When Forge (or an agent driving Forge) discovers a pattern strong
+enough to become a new tool / feature, it can submit an enhancement
+proposal. Proposals are logged as JSONL; an optional AAAA-Nexus
+trust-gate call gives the proposal a trust score; publishing to
+GitHub stays human-gated (never auto-posted).
+"""
+from __future__ import annotations
+
+from typing import Final
+
+SCHEMA_VERSION_ENHANCEMENT_PROPOSAL_V1: Final[str] = (
+    "atomadic-forge.enhancement_proposal/v1"
+)
+
+PROPOSAL_DIR_REL: Final[str] = ".atomadic-forge/enhancement_proposals"
+PROPOSAL_LOG_REL: Final[str] = (
+    ".atomadic-forge/enhancement_proposals/forge_enhancement_proposals.jsonl"
+)
+
+# Trust threshold below which a proposal is logged-only (never published).
+# Above this, the proposal becomes eligible for `forge enhancement publish`
+# (which still requires an explicit human approval).
+DEFAULT_TRUST_THRESHOLD: Final[float] = 0.75
+
+# Trust verdicts accepted from the trust-gate response.
+TRUST_VERDICT_PASS: Final[str] = "PASS"
+TRUST_VERDICT_FAIL: Final[str] = "FAIL"
+TRUST_VERDICT_OFFLINE: Final[str] = "OFFLINE"
+TRUST_VERDICT_VALUES: Final[frozenset[str]] = frozenset({
+    TRUST_VERDICT_PASS, TRUST_VERDICT_FAIL, TRUST_VERDICT_OFFLINE,
+})
+
+__all__ = [
+    "DEFAULT_TRUST_THRESHOLD",
+    "PROPOSAL_DIR_REL",
+    "PROPOSAL_LOG_REL",
+    "SCHEMA_VERSION_ENHANCEMENT_PROPOSAL_V1",
+    "TRUST_VERDICT_FAIL",
+    "TRUST_VERDICT_OFFLINE",
+    "TRUST_VERDICT_PASS",
+    "TRUST_VERDICT_VALUES",
+]

atomadic_forge-0.14.1/src/atomadic_forge/a0_qk_constants/response_enrichment.py

@@ -0,0 +1,38 @@
+"""Tier a0 — response-enrichment constants.
+
+The ``scope`` block surfaces real measurements the tool already produced
+(files scanned, symbols analyzed, traversal depth, wall-clock time)
+alongside a transparent token-savings ESTIMATE. Every estimate ships
+with its formula in ``tokens_saved_basis`` so a reader can audit the
+math instead of trusting the number.
+
+Defaults are conservative middle-ground heuristics. They will land in
+the wrong neighborhood for any specific agent/model/prompt combo;
+``tokens_saved_basis`` is always present so callers can see exactly
+how the number was derived and recompute if they want a different
+baseline.
+"""
+from __future__ import annotations
+
+from typing import Final
+
+SCHEMA_VERSION_SCOPE_V1: Final[str] = "atomadic-forge.scope/v1"
+
+# Per-file token cost a human/agent would pay to manually open + scan
+# one source file end-to-end. 40 tok ≈ ~150 chars ≈ a small Python
+# module's signatures + dependencies (NOT full body). This is the
+# lower-bound "bare review" cost; full reading + reasoning is much
+# higher. We pick the lower bound deliberately so the estimate cannot
+# be accused of inflating ROI.
+TOKENS_PER_FILE_REVIEW: Final[int] = 40
+
+# Per-symbol cost for traversal-style operations (emergent_scan,
+# call_graph). One symbol ≈ ~12 tok of read cost when an agent is
+# building a mental graph of a codebase.
+TOKENS_PER_SYMBOL_TRAVERSAL: Final[int] = 12
+
+__all__ = [
+    "SCHEMA_VERSION_SCOPE_V1",
+    "TOKENS_PER_FILE_REVIEW",
+    "TOKENS_PER_SYMBOL_TRAVERSAL",
+]

{atomadic_forge-0.14.0 → atomadic_forge-0.14.1}/src/atomadic_forge/a0_qk_constants/schema_version_registry.py

@@ -116,6 +116,13 @@ SCHEMA_VERSIONS: dict[str, str] = {
     # v0.14.0a9 — handoff: structured agent-to-agent session transfer
     "handoff_create":  "atomadic-forge.handoff/v1",
     "handoff_list":    "atomadic-forge.handoff/v1",
+
+    # v0.14.0a11 — enhancement proposals (trust-gated, human-published)
+    "enhancement_propose": "atomadic-forge.enhancement_proposal/v1",
+    "enhancement_list":    "atomadic-forge.enhancement_proposal/v1",
+
+    # v0.14.0a12 — welcome: first-call handshake
+    "welcome": "atomadic-forge.welcome/v1",
 }
 
 

atomadic_forge-0.14.1/src/atomadic_forge/a0_qk_constants/welcome_constants.py

@@ -0,0 +1,38 @@
+"""Tier a0 — forge welcome constants.
+
+The welcome flow is the first call an agent makes after connecting to
+Forge. It runs a focused recon (scout + certify + wire) and packages
+the result so the agent immediately knows three things:
+
+  1. What state the repo is actually in (numbers, not vibes)
+  2. What Forge can do for it from here (capability surface)
+  3. The single most useful next call
+
+Voice for the narrative is "senior architect reporting from a scan" —
+specific, grounded, confident. No marketing copy, no sycophancy.
+"""
+from __future__ import annotations
+
+from typing import Final
+
+SCHEMA_VERSION_WELCOME_V1: Final[str] = "atomadic-forge.welcome/v1"
+
+# Score thresholds map to one-word health labels in the narrative.
+HEALTH_LABEL_THRESHOLDS: Final[tuple[tuple[float, str], ...]] = (
+    (95.0, "production-ready"),
+    (85.0, "ship-ready"),
+    (70.0, "improving"),
+    (50.0, "needs work"),
+    (0.0, "early"),
+)
+
+# Cap suggestions / strengths so the response stays scannable.
+TOP_N_STRENGTHS: Final[int] = 3
+TOP_N_PRIORITIES: Final[int] = 3
+
+__all__ = [
+    "HEALTH_LABEL_THRESHOLDS",
+    "SCHEMA_VERSION_WELCOME_V1",
+    "TOP_N_PRIORITIES",
+    "TOP_N_STRENGTHS",
+]

{atomadic_forge-0.14.0 → atomadic_forge-0.14.1}/src/atomadic_forge/a1_at_functions/certify_checks.py

@@ -457,7 +457,11 @@ def certify(root: Path, *, project: str = "Atomadic project",
     scan_duration_ms = int((time.perf_counter() - _scan_start) * 1000)
     blockers = len([i for i in issues if not i.startswith("  ·")])
     verdict = "PASS" if score >= 75 and blockers == 0 else "FAIL"
-    return {
+    _files_scanned_estimate = sum(
+        v for v in (layout_d.get("file_class_counts") or {}).values()
+        if isinstance(v, int)
+    ) or len(list((root / "src").rglob("*.py")) if (root / "src").is_dir() else [])
+    base = {
         "schema_version": "atomadic-forge.certify/v1",
         "project": project,
         "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
@@ -557,3 +561,18 @@ def certify(root: Path, *, project: str = "Atomadic project",
                    "test_run": test_run,
                    "untiered_source": count_untiered_source_files(root)},
     }
+    from .response_enricher import (
+        enrich_response as _enrich,
+        make_scope as _make_scope,
+        summarize_certify as _summarize_certify,
+    )
+    return _enrich(
+        base,
+        scope=_make_scope(
+            files_scanned=_files_scanned_estimate,
+            tiers_traversed=5,
+            scan_duration_ms=scan_duration_ms,
+            basis_kind="files",
+        ),
+        summary=_summarize_certify(base),
+    )