attocode-code-intel 0.1.4__tar.gz → 0.1.6__tar.gz

{attocode_code_intel-0.1.4 → attocode_code_intel-0.1.6}/.gitignore

@@ -80,3 +80,6 @@ scripts/*
 
 # search-quality sweep scratch output
 eval/sweep_out/
+
+# Bounded validation workspaces, reports and cloud ledger
+.attocode/quality/

{attocode_code_intel-0.1.4 → attocode_code_intel-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: attocode-code-intel
-Version: 0.1.4
+Version: 0.1.6
 Summary: Local code search and navigation for coding agents and people
 Project-URL: Homepage, https://github.com/eren23/attocode
 Project-URL: Repository, https://github.com/eren23/attocode
@@ -152,6 +152,15 @@ The agent sees 16 tools (the `daily` profile):
 
 For all tools (about 140: rules, security scans, history, snapshots and more), add `--profile full` to `init`. The [tool catalog](https://github.com/eren23/attocode/blob/main/docs/intelligence-tools.md) lists them. The [search details](https://github.com/eren23/attocode/blob/main/docs/intelligence-search.md) page describes ranking, the response format and the experimental rerankers.
 
+For an experimental local seven-tool surface (0.1.5 or later), use
+`init --profile lean` and restart your client. It advertises `bootstrap`,
+`search_symbols`, `inspect_symbol`, `semantic_search`, `impact_analysis`,
+`suggest_tests` and `capabilities`, with conditional routing instructions
+and 2,000-token responses. Without file watching, `notify_file_changed`
+is an eighth tool. Advanced tools require a full-profile session.
+This opt-in profile has no demonstrated completion benefit; see the
+[completed pilot](https://github.com/eren23/attocode/blob/main/packages/code-intel/evals/results/2026-10-14-r7-completion-pilot.md).
+
 ## Commands for people
 
 Run these in your project:
@@ -172,14 +181,16 @@ Search matches the words of the code and its paths. It does not use embeddings u
 - **Search.** We ran the 560 issues of Loc-Bench V1, with the full issue as the query. For 53.2% of them, the first five files held all files of the fix (file Acc@5 0.532). On a mix of 10 public benchmarks, file Acc@5 was 0.425. See the [first-stage results](https://github.com/eren23/attocode/blob/main/packages/code-intel/evals/results/2026-10-09-locbench-560-first-stage.md) and the [matrix results](https://github.com/eren23/attocode/blob/main/packages/code-intel/evals/results/2026-10-10-matrix-r1.md).
 - **Agents.** In four studies, Claude Code (Sonnet 5.5) named the files to edit for an issue. The server did not raise file Acc@5. Each run with the server cost 1.4 to 2.1 times as much. When the agent could choose, it seldom called the server. See the [agent pilot](https://github.com/eren23/attocode/blob/main/packages/code-intel/evals/results/2026-10-10-agent-pilot.md) and [study R3](https://github.com/eren23/attocode/blob/main/packages/code-intel/evals/results/2026-10-10-agent-r3.md).
 
-We have not tested longer agent tasks, such as edits or reviews.
+The [R6 review study](https://github.com/eren23/attocode/blob/main/packages/code-intel/evals/results/2026-10-13-r6-review-test-note.md)
+found no demonstrated review benefit. The [completed R7 repair pilot](https://github.com/eren23/attocode/blob/main/packages/code-intel/evals/results/2026-10-14-r7-completion-pilot.md)
+also found no demonstrated benefit; its reviewed decision is to stop expansion.
 
 ## Limits and troubleshooting
 
 - **First search.** The first tool call starts the index build. A search waits up to 15 seconds for the index. On a large repository, a search can report that the index is warming. Then search again. An empty result during warm-up does not prove that the code is absent.
 - **Index location.** The index is in `.attocode/` in your project. When the server makes that folder, it adds a `.gitignore`, so the index stays out of commits.
-- **What the index reads.** The server reads at most 50,000 files and skips files over 1 MB. It skips files that `.gitignore` ignores, and folders that start with a dot. It also skips folders named `build`, `out`, `output`, `target`, `env`, `tmp`, `vendor` or `coverage`, and binary, media and lock files.
-- **Languages.** The base install parses Bash, C, C#, C++, CSS, Elixir, Go, HCL, HTML, Java, JavaScript, JSON, Kotlin, Lua, PHP, Python, Ruby, Rust, Scala, Swift, TOML, TypeScript, YAML and Zig. The `tree-sitter-all` extra adds about 170 more.
+- **What the index reads.** The server reads at most 50,000 files and skips files over 1 MB. It skips files that `.gitignore` ignores, and folders that start with a dot. It also skips folders named `dist`, `build`, `out`, `output`, `target`, `env`, `tmp`, `vendor` or `coverage`, and binary, media and lock files. If a build-named folder contains real source, explicitly re-include it with a root `.gitignore` entry such as `!dist/`; discovery and edit refresh honor that override.
+- **Languages.** The base install parses Bash, C, C#, C++, CSS, Elixir, Go, HCL, HTML, Java, JavaScript, JSON, Kotlin, Lua, PHP, Python, Ruby, Rust, Scala, Swift, TOML, TypeScript, YAML and Zig. Optional grammars are loaded only when already installed or cached; installing the `tree-sitter-all` extra does not trigger grammar downloads during navigation. A slow grammar falls back after a 100 ms parse budget. Static imports and references are partial evidence, not compiler/type resolution.
 - **Remove the setup.** Run `attocode-code-intel init --remove`. It restores an entry that existed before `init`.
 - **Server does not answer.** Run `attocode-code-intel doctor`. If a client shows "not configured", run `init` for it. After a change, restart the agent. In Claude Code, `/mcp` shows the server state.
 - **HTTP server.** `attocode-code-intel --transport http` needs the `http` extra. It serves only this computer unless you set `ATTOCODE_API_KEY`.
@@ -216,6 +227,12 @@ uv run pytest -c packages/code-intel/pyproject.toml --confcutdir=packages/code-i
 uv build --package attocode-code-intel
 ```
 
+For routine work, use `.venv/bin/python -m eval.quality quick` (two minutes)
+or `local` (ten minutes). They isolate scratch and caches in a monitored 5 GiB
+workspace and report incomplete runs separately from passes. The
+[quality guide](https://github.com/eren23/attocode/blob/main/docs/intelligence-quality.md) covers pinned multi-language
+workflow checks, storage inventory, cleanup and optional CPU cloud batches.
+
 Releases use `intel-v*` tags ([release guide](https://github.com/eren23/attocode/blob/main/docs/intelligence-release.md)).
 
 [Product and operations guide](https://github.com/eren23/attocode/blob/main/docs/intelligence.md) · [Tool catalog](https://github.com/eren23/attocode/blob/main/docs/intelligence-tools.md) · [Search details](https://github.com/eren23/attocode/blob/main/docs/intelligence-search.md) · [Changelog](https://github.com/eren23/attocode/blob/main/CHANGELOG.md) · [MIT license](https://github.com/eren23/attocode/blob/main/packages/code-intel/LICENSE)

{attocode_code_intel-0.1.4 → attocode_code_intel-0.1.6}/README.md

@@ -40,6 +40,15 @@ The agent sees 16 tools (the `daily` profile):
 
 For all tools (about 140: rules, security scans, history, snapshots and more), add `--profile full` to `init`. The [tool catalog](https://github.com/eren23/attocode/blob/main/docs/intelligence-tools.md) lists them. The [search details](https://github.com/eren23/attocode/blob/main/docs/intelligence-search.md) page describes ranking, the response format and the experimental rerankers.
 
+For an experimental local seven-tool surface (0.1.5 or later), use
+`init --profile lean` and restart your client. It advertises `bootstrap`,
+`search_symbols`, `inspect_symbol`, `semantic_search`, `impact_analysis`,
+`suggest_tests` and `capabilities`, with conditional routing instructions
+and 2,000-token responses. Without file watching, `notify_file_changed`
+is an eighth tool. Advanced tools require a full-profile session.
+This opt-in profile has no demonstrated completion benefit; see the
+[completed pilot](https://github.com/eren23/attocode/blob/main/packages/code-intel/evals/results/2026-10-14-r7-completion-pilot.md).
+
 ## Commands for people
 
 Run these in your project:
@@ -60,14 +69,16 @@ Search matches the words of the code and its paths. It does not use embeddings u
 - **Search.** We ran the 560 issues of Loc-Bench V1, with the full issue as the query. For 53.2% of them, the first five files held all files of the fix (file Acc@5 0.532). On a mix of 10 public benchmarks, file Acc@5 was 0.425. See the [first-stage results](https://github.com/eren23/attocode/blob/main/packages/code-intel/evals/results/2026-10-09-locbench-560-first-stage.md) and the [matrix results](https://github.com/eren23/attocode/blob/main/packages/code-intel/evals/results/2026-10-10-matrix-r1.md).
 - **Agents.** In four studies, Claude Code (Sonnet 5.5) named the files to edit for an issue. The server did not raise file Acc@5. Each run with the server cost 1.4 to 2.1 times as much. When the agent could choose, it seldom called the server. See the [agent pilot](https://github.com/eren23/attocode/blob/main/packages/code-intel/evals/results/2026-10-10-agent-pilot.md) and [study R3](https://github.com/eren23/attocode/blob/main/packages/code-intel/evals/results/2026-10-10-agent-r3.md).
 
-We have not tested longer agent tasks, such as edits or reviews.
+The [R6 review study](https://github.com/eren23/attocode/blob/main/packages/code-intel/evals/results/2026-10-13-r6-review-test-note.md)
+found no demonstrated review benefit. The [completed R7 repair pilot](https://github.com/eren23/attocode/blob/main/packages/code-intel/evals/results/2026-10-14-r7-completion-pilot.md)
+also found no demonstrated benefit; its reviewed decision is to stop expansion.
 
 ## Limits and troubleshooting
 
 - **First search.** The first tool call starts the index build. A search waits up to 15 seconds for the index. On a large repository, a search can report that the index is warming. Then search again. An empty result during warm-up does not prove that the code is absent.
 - **Index location.** The index is in `.attocode/` in your project. When the server makes that folder, it adds a `.gitignore`, so the index stays out of commits.
-- **What the index reads.** The server reads at most 50,000 files and skips files over 1 MB. It skips files that `.gitignore` ignores, and folders that start with a dot. It also skips folders named `build`, `out`, `output`, `target`, `env`, `tmp`, `vendor` or `coverage`, and binary, media and lock files.
-- **Languages.** The base install parses Bash, C, C#, C++, CSS, Elixir, Go, HCL, HTML, Java, JavaScript, JSON, Kotlin, Lua, PHP, Python, Ruby, Rust, Scala, Swift, TOML, TypeScript, YAML and Zig. The `tree-sitter-all` extra adds about 170 more.
+- **What the index reads.** The server reads at most 50,000 files and skips files over 1 MB. It skips files that `.gitignore` ignores, and folders that start with a dot. It also skips folders named `dist`, `build`, `out`, `output`, `target`, `env`, `tmp`, `vendor` or `coverage`, and binary, media and lock files. If a build-named folder contains real source, explicitly re-include it with a root `.gitignore` entry such as `!dist/`; discovery and edit refresh honor that override.
+- **Languages.** The base install parses Bash, C, C#, C++, CSS, Elixir, Go, HCL, HTML, Java, JavaScript, JSON, Kotlin, Lua, PHP, Python, Ruby, Rust, Scala, Swift, TOML, TypeScript, YAML and Zig. Optional grammars are loaded only when already installed or cached; installing the `tree-sitter-all` extra does not trigger grammar downloads during navigation. A slow grammar falls back after a 100 ms parse budget. Static imports and references are partial evidence, not compiler/type resolution.
 - **Remove the setup.** Run `attocode-code-intel init --remove`. It restores an entry that existed before `init`.
 - **Server does not answer.** Run `attocode-code-intel doctor`. If a client shows "not configured", run `init` for it. After a change, restart the agent. In Claude Code, `/mcp` shows the server state.
 - **HTTP server.** `attocode-code-intel --transport http` needs the `http` extra. It serves only this computer unless you set `ATTOCODE_API_KEY`.
@@ -104,6 +115,12 @@ uv run pytest -c packages/code-intel/pyproject.toml --confcutdir=packages/code-i
 uv build --package attocode-code-intel
 ```
 
+For routine work, use `.venv/bin/python -m eval.quality quick` (two minutes)
+or `local` (ten minutes). They isolate scratch and caches in a monitored 5 GiB
+workspace and report incomplete runs separately from passes. The
+[quality guide](https://github.com/eren23/attocode/blob/main/docs/intelligence-quality.md) covers pinned multi-language
+workflow checks, storage inventory, cleanup and optional CPU cloud batches.
+
 Releases use `intel-v*` tags ([release guide](https://github.com/eren23/attocode/blob/main/docs/intelligence-release.md)).
 
 [Product and operations guide](https://github.com/eren23/attocode/blob/main/docs/intelligence.md) · [Tool catalog](https://github.com/eren23/attocode/blob/main/docs/intelligence-tools.md) · [Search details](https://github.com/eren23/attocode/blob/main/docs/intelligence-search.md) · [Changelog](https://github.com/eren23/attocode/blob/main/CHANGELOG.md) · [MIT license](https://github.com/eren23/attocode/blob/main/packages/code-intel/LICENSE)

{attocode_code_intel-0.1.4 → attocode_code_intel-0.1.6}/evals/README.md

@@ -204,6 +204,14 @@ The primary comparisons are ΔAcc@5 and the geometric mean cost ratio. The repor
 
 With `--matrix OUT`, the report reads the rows of one offline cell (`--offline-cell`, default `product`) at variant `full` in `OUT/results.jsonl`. For each setup, it correlates the offline reciprocal rank of the first gold file with the agent Acc@5 (Spearman). It also gives a 2×2 table of offline hit@5 and agent hit. An agent hit is a task mean Acc@5 of 0.5 or more. The report counts the tasks without an offline row and does not score them.
 
+## Agent review study
+
+`study.py freeze --mode review` freezes a change-review study (R4 Stage 1). It uses the harness and the commands of the localization study. Each line of `--instances` has `id` (`dataset/native`), `repo`, `base_commit`, `patch` and `gold`. The gold files are the existing test files that the fix changed. `prepare` applies the patch to the one-commit snapshot without a commit. New files are intent-to-add, so `git diff` shows them. A review study has no `issue_only` setup.
+
+The frozen prompt `REVIEW_PROMPT_V2` asks for the existing test files that check the change. The answer is `{"tests": [...]}`: at most 10 paths, best first. All setups get `Read`, `Grep`, `Glob` and `Bash` (`Bash(git diff:*)` with `--permission-mode dontAsk`). Claude Code runs read-only commands, such as `git diff` and `ls`, without a rule. It denies other commands, for example a test run or a file write. A denied call does not fail the run, and `summary` counts the denied calls. `intel_first` asks the agent to run `git diff --name-only` and then to call `suggest_tests` once with those files. The wiring check also proves that `git diff` runs and that `touch` is denied.
+
+`summary` scores test Recall@5 and Hit@5. For each run, `gold_shown_not_named` lists the gold tests that an MCP result named. The answer did not name them.
+
 ## Ranking gate
 
 `python -m eval.matrix.run ci` is a regression gate for search ranking. The Ranking gate workflow runs it when a pull request changes `packages/code-intel/src/`, `eval/matrix/` or `uv.lock`. The engine hash of the matrix covers all of `packages/code-intel/src/`, so a change in any of these files can move the ranking.
@@ -295,3 +303,75 @@ The table gives the core mix on the full query. The metric is Acc@5, but gNDCG@5
 No difference on the core mix passes the Holm test. The datasets are small.
 
 The earlier result (v1, also on 2026-10-09) ranked all stored files. It embedded at most 40 windows (1,600 lines) of a file and cut the query at 512 tokens. Markdown, reStructuredText, YAML and text files were about a fifth of the first ten files of `dense`. On the full issue of Loc-Bench 560, `dense` gave Acc@5 0.541 and `rrf(product+dense)` 0.664, against 0.532 for `product`. With only the Python files, `dense` gave 0.609. That pod embedded 1.99 million windows for about $1.7.
+
+
+## Repair completion pilot
+
+R7 compares optional local lean MCP with native tools on eight public
+SWE-bench Lite tasks from eight repositories, two trials per arm. The
+[protocol](designs/2026-10-13-r7-task-completion-pilot.md) fixes the outcome-first
+continuation gate. Adoption is descriptive. Host reads and edits use trace
+audit; Docker execution and independent grading have no network. This is
+not an OS sandbox for the host client.
+
+Use a separate Python 3.12 environment with PyArrow and SWE-bench pinned to
+`726c5461e2ef52d83cf1ea2107870a8bb3328d57`. The worker checks its installed
+commit and records dependency versions. Keep every pack/study outside this
+repository. A pack contains private reference patches, official tests and
+complete test lists; never mount it into an agent workspace.
+
+```sh
+# Preparation only: no Claude requests or quota check.
+EVALUATOR=/path/to/isolated-evaluator/bin/python
+PACK=/path/to/new-private-pack
+STUDY=/path/to/new-study
+DATASET=/path/to/lite@97f9af8814fe7eb15dcd9b2abaa9010e1eadda63/data/test-00000-of-00001.parquet
+"$EVALUATOR" packages/code-intel/evals/repair_worker.py prepare-pack --dataset "$DATASET" --pack "$PACK"
+.venv/bin/python packages/code-intel/evals/study.py freeze --mode repair --model claude-sonnet-5-5 --trials 2 --benchmark-pack "$PACK" --evaluator-python "$EVALUATOR" --study "$STUDY"
+PYTHONPATH="$STUDY/engine" .venv/bin/python "$STUDY/harness/study.py" prepare --study "$STUDY"
+PYTHONPATH="$STUDY/engine" .venv/bin/python "$STUDY/harness/study.py" wiring --offline --study "$STUDY"
+PYTHONPATH="$STUDY/engine" .venv/bin/python "$STUDY/harness/study.py" summary --study "$STUDY"
+```
+
+Preparation downloads task images and build wheels before offline tests,
+uses deterministic SHA-256 repository/task order, preserves exclusions,
+and requires image-only and mounted-source base/gold controls plus rejection
+of a synthetic regression. The strict grader requires every F2P and P2P
+ID to be observed PASSED and an actual zero test-command exit status.
+Missing, skipped, timed-out and unexecuted tests cannot pass. No regression
+cap is applied. Candidate changes to official test paths are restored
+before the immutable official patch. Submitted patches and logs remain
+available; stale cached verdicts are rejected.
+
+`prepare` validates the controls with the frozen harness. Exact-input
+cache reuse requires matching task, image, patch, source, evaluator and
+worker/grader hashes; drift is rejected. `wiring --offline`
+checks Docker command execution, the actual seven MCP tools and visibility
+of a container edit through inspection. It records `model_wiring: pending`.
+Scored `run` refuses to call a model until two separate excluded model
+wiring attempts pass. Those checks and the 32 scored runs are **not part of
+the build-and-prepare authorization**. Future execution requires fresh
+subscription-only quota observations, disabled paid usage, at most two
+workers, 50-minute sessions and a $20 cumulative client-estimate soft cap.
+Preserve failed/interrupted attempts; never change frozen inputs to resume.
+
+## Bounded Codex repair diagnostic
+
+`codex_repair_study.py` is a separate, explicitly authorized six-request
+diagnostic: two excluded wiring checks, then four repairs on the first two
+prepared R7 tasks with native/optional lean arms. It leaves Claude R7 frozen.
+Read the [design](designs/2026-10-13-codex-repair-diagnostic.md) before use.
+Freeze to a new external directory, then run the frozen harness's `prepare`,
+`wiring --index 0/1` and `repair --index 0/1/2/3` actions individually.
+Both wiring traces require a clear operator `review.json` before repairs.
+Preserve all attempts; no retries or replacement tasks.
+
+It reuses ChatGPT login in a private disposable client home, suppresses
+personal guidance/features per invocation, verifies instruction sources
+without a model turn, and pins `gpt-6.1-sol` at high reasoning. It checks fresh
+included quota before every request and stops if the observed credit balance
+decreases. This is an observational spending guard, not a provider-enforced
+credit prohibition. Strict independent grading is shared with R7; all shell
+commands and file edits still require review. Token usage is reported without
+an invented USD estimate. Four development repairs cannot establish an
+intelligence benefit or support a comparison between models.

attocode_code_intel-0.1.6/evals/ast_restart_probe.py

@@ -0,0 +1,101 @@
+"""Generated Go cold+restart comparison with exact AST/index parity and cleanup."""
+from __future__ import annotations
+
+import ast
+import hashlib
+import json
+import platform
+import subprocess
+import tempfile
+import time
+from dataclasses import asdict
+from pathlib import Path
+from unittest.mock import patch
+
+from attocode_intel._internal.integrations.context import ast_service, ast_snapshot, codebase_ast
+from attocode_intel._internal.integrations.context.index_store import AST_SNAPSHOT_KEY
+
+BASELINE = 'b3501b9d7ae016572d77ceae1289026d23719694'
+SOURCE = 'packages/code-intel/src/attocode_intel/_internal/integrations/context/ast_service.py'
+
+
+def run():
+    source = subprocess.check_output(['git', 'show', f'{BASELINE}:{SOURCE}'], timeout=10)
+    cls = next(n for n in ast.parse(source).body if isinstance(n, ast.ClassDef) and n.name == 'ASTService')
+    methods, scopes = {}, []
+    for name in ('initialize_skeleton', '_save_snapshot', '_restore_snapshot'):
+        method = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == name)
+        scope = dict(vars(ast_service))
+        exec(compile(ast.Module(body=[method], type_ignores=[]), '<frozen restart>', 'exec'), scope)
+        methods[name] = scope[name]
+        scopes.append(scope)
+    original = {name: getattr(ast_service.ASTService, name) for name in methods}
+    observations = []
+    with tempfile.TemporaryDirectory(prefix='attocode-restart-probe-') as tmp:
+        root = Path(tmp)
+        workloads = ['short_body', 'long_body']
+        source_sizes = {}
+        for number, (workload, mode) in enumerate((w, m) for w in workloads
+                for m in ['baseline', 'candidate', 'candidate', 'baseline']):
+            for scope in scopes:
+                scope['parse_file'] = ast_service.parse_file
+            project = root / str(number)
+            project.mkdir()
+            for i in range(160):
+                (project / f'file{i:04d}.go').write_text('package example\n' + ''.join(
+                    f'// Helper{i}_{j} returns an adjusted value.\nfunc Helper{i}_{j}(value int) int {{\n'
+                    + '    if value < 0 { return 0 }\n' * (1 if workload == 'short_body' else 12)
+                    + '    return value + 1\n}\n' for j in range(32)))
+            source_sizes[workload] = sum(p.stat().st_size for p in project.iterdir())
+            assert source_sizes[workload] < 8 * 2**20
+            with patch.multiple(ast_service.ASTService, **(methods if mode == 'baseline' else original)):
+                first = ast_service.ASTService(str(project))
+                start = time.monotonic()
+                try:
+                    first.initialize_skeleton(indexing_depth='eager')
+                    cold = time.monotonic() - start
+                    payload_bytes = len((first._store.get_meta(AST_SNAPSHOT_KEY) or '').encode())
+                finally:
+                    first.stop_hydration()
+                    first._store.close()
+                second = ast_service.ASTService(str(project))
+                try:
+                    with (patch.object(ast_service, 'parse_file', wraps=ast_service.parse_file) as parse,
+                          patch.object(codebase_ast, 'parse_file', parse)):
+                        for scope in scopes:
+                            scope['parse_file'] = parse
+                        wall, cpu = time.monotonic(), time.thread_time()
+                        state = second.initialize_skeleton()
+                        restart, thread_cpu = time.monotonic()-wall, time.thread_time()-cpu
+                        calls = parse.call_count
+                    assert state.phase == 'ready' and state.parsed_files == 160
+                    assert calls == (320 if mode == 'baseline' else 0)
+                    summaries = {key: {**asdict(value), 'path': key} for key, value in second._ast_cache.items()}
+                    evidence = {'asts': summaries, 'definitions': {
+                        key: [asdict(v) for v in value] for key, value in second._index.definitions.items()},
+                        'stats': second._store.stats(), 'dependencies': {
+                            key: sorted(value) for key, value in second._index.file_dependencies.items()}}
+                    digest = hashlib.sha256(json.dumps(evidence, sort_keys=True).encode()).hexdigest()
+                    observations.append({'mode': mode, 'workload': workload, 'cold_seconds': cold, 'restart_seconds': restart,
+                                         'cold_plus_restart_seconds': cold+restart, 'restart_thread_cpu_seconds': thread_cpu,
+                                         'restart_parse_calls': calls, 'cache_payload_bytes': payload_bytes,
+                                         'evidence_sha256': digest})
+                finally:
+                    second.stop_hydration()
+                    second._store.close()
+        for workload in workloads:
+            assert len({row['evidence_sha256'] for row in observations if row['workload'] == workload}) == 1
+        disk_bytes = sum(p.stat().st_size for p in root.rglob('*') if p.is_file())
+        assert disk_bytes < 100 * 2**20
+    return {'scope': 'Generated 160-file/5120-function Go cold+restart; no Cockroach or cloud speed claim',
+            'baseline_commit': BASELINE, 'baseline_source_sha256': hashlib.sha256(source).hexdigest(),
+            'candidate_source_sha256': hashlib.sha256(Path(ast_service.__file__).read_bytes()).hexdigest(),
+            'cache_source_sha256': hashlib.sha256(Path(ast_snapshot.__file__).read_bytes()).hexdigest(),
+            'probe_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+            'python': platform.python_version(), 'platform': platform.platform(),
+            'source_bytes': source_sizes, 'final_owned_disk_bytes': disk_bytes,
+            'observations': observations, 'cleanup_verified': not root.exists()}
+
+
+if __name__ == '__main__':
+    print(json.dumps(run(), indent=2))

attocode_code_intel-0.1.6/evals/body_cost_probe.py

@@ -0,0 +1,101 @@
+"""Bounded generated body-work probe: no downloads, models or cloud resources.
+
+This isolates document generation, using empty known spans (no AST parsing), not
+an end-to-end repository benchmark. Compare identical terms/windows by digest.
+"""
+from __future__ import annotations
+
+import argparse
+import ast
+import hashlib
+import inspect
+import json
+import platform
+import subprocess
+import tempfile
+import time
+from contextlib import nullcontext
+from functools import partial
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from attocode_intel._internal.integrations.context import index_probe as probe
+from attocode_intel._internal.integrations.context import semantic_search as search
+
+BASELINE = "3d7c41ca628e8dfd2f62cf7eff9c4ae3aadbbdc2"
+SOURCE = "packages/code-intel/src/attocode_intel/_internal/integrations/context/semantic_search.py"
+
+
+def baseline_body():
+    source = subprocess.check_output(["git", "show", f"{BASELINE}:{SOURCE}"], timeout=10)
+    cls = next(n for n in ast.parse(source).body if isinstance(n, ast.ClassDef) and n.name == "SemanticSearchManager")
+    method = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == "_body_document")
+    method.decorator_list = []
+    scope = dict(vars(search))
+    exec(compile(ast.Module(body=[method], type_ignores=[]), "<frozen body>", "exec"), scope)
+    return scope[method.name], hashlib.sha256(source).hexdigest()
+
+
+def fixture(root, unique=False):
+    paths = []
+    for i in range(8):
+        path = root / f'generated{i}.go'
+        path.write_text('package example\n' + ''.join(
+            f'// block {n if unique else n // 32}\nvalue_{n if unique else n % 64} = otherHTTPValue + processRow(value_{n if unique else n % 64})\n'
+            for n in range(2048)
+        ))
+        paths.append(path)
+    return paths
+
+
+def run():
+    observations = []
+    legacy, baseline_hash = baseline_body()
+    source_bytes = {}
+    with tempfile.TemporaryDirectory(prefix='attocode-body-cost-') as tmp:
+        for workload in ('repeated', 'unique'):
+            root = Path(tmp) / workload
+            root.mkdir()
+            paths = fixture(root, unique=workload == 'unique')
+            source_bytes[workload] = sum(p.stat().st_size for p in paths)
+            assert source_bytes[workload] < 2 * 2**20
+            modes = ['baseline_off', 'off', 'all_calls', 'default']
+            for rotation in range(4):
+                for mode in modes[rotation:] + modes[:rotation]:
+                    collector = None if mode in ('baseline_off', 'off') else probe.IndexProbe()
+                    wrapping = (patch.object(search, 'instrument', lambda phase, fn:
+                                partial(probe.measured_call, phase, fn))
+                                if mode == 'all_calls' else nullcontext())
+                    method = legacy if mode == 'baseline_off' else search.SemanticSearchManager._body_document
+                    outputs = []
+                    with wrapping, probe.activate(collector):
+                        wall, cpu = time.monotonic(), time.thread_time()
+                        for p in paths:
+                            outputs.append(method(
+                                p.name, str(p), SimpleNamespace(take=lambda *_: ([], [])),
+                                include_file_terms=True,
+                            ))
+                        elapsed, used = time.monotonic()-wall, time.thread_time()-cpu
+                    digest = hashlib.sha256(json.dumps(outputs, ensure_ascii=False).encode()).hexdigest()
+                    observations.append({'workload': workload, 'mode': mode, 'rotation': rotation,
+                                         'wall_seconds': elapsed, 'thread_cpu_seconds': used,
+                                         'output_sha256': digest,
+                                         'windows': sum(len(o[0]) for o in outputs),
+                                         'profile': collector.snapshot() if collector else None})
+            assert len({o['output_sha256'] for o in observations if o['workload'] == workload}) == 1
+    return {'scope': 'Generated document generation, empty known spans; no parsing, SQL or cold-start claim',
+            'baseline_commit': BASELINE, 'baseline_source_sha256': baseline_hash,
+            'candidate_source_sha256': hashlib.sha256(Path(inspect.getfile(search)).read_bytes()).hexdigest(),
+            'profiler_sha256': hashlib.sha256(Path(inspect.getfile(probe)).read_bytes()).hexdigest(),
+            'probe_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+            'python': platform.python_version(), 'platform': platform.platform(),
+            'source_bytes': source_bytes, 'observations': observations,
+            'cleanup_verified': not Path(tmp).exists()}
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--output', type=Path, required=True)
+    args = parser.parse_args()
+    args.output.write_text(json.dumps(run(), indent=2)+'\n')