@azure-id/orc 1.8.1 → 1.8.2

package/CHANGELOG.md

@@ -10,6 +10,226 @@ Format: `### v<version> — <title> _(<date>)_`.
 
 ---
 
+### v1.8.2 — the map that finds what a grep cannot _(2026-09-21)_
+
+**Still on the unscoped `orc` package?** Do this once first - your `orc upgrade`
+is the pre-v0.56.0 one and cannot install itself. Full detail in the CAUTION at
+the top of this file.
+
+- **Step 1 - release the command from the old package:** `npm uninstall -g orc`
+- **Step 2 - install the current package:** `npm i -g @azure-id/orc`
+- **Step 3 - re-apply it to your project:** `orc update`
+
+**Do not use `npm i -g -f`.** Full detail in v0.56.0 below.
+
+v1.8.0 shipped the code graph with a known hole. A card listed every caller that
+NAMES a symbol, so a test that reaches a route by its URL was not a caller, and
+the card was silent about it. On one real question the graph declared eleven
+route-level tests absent. This release closes that hole and four more like it,
+adds five languages, and makes the map answer faster than it could before.
+
+**Nothing you have to do.** The index upgrades itself. Engine `graph@5` re-reads
+every record the first time you run `orc graph update` after this release; a
+Django-sized repository takes about 14 s once, and every update after that is
+small again. The graph is still **off by default**: `orc config set code_graph on`.
+
+**A URL is now an edge.**
+
+- `request(app).get("/orders/search")`, `client.post("/api/orders/")` and
+  `httptest.NewRequest("GET", "/p")` reach the route they resolve to. The card
+  prints `← reached via GET /orders/search tests/orders.test.js:27 ROUTE`,
+  `orc graph impact` follows it, `orc graph changes` counts it, and the `tests`
+  line names the test file.
+- A decorated handler keeps its own symbol and gains a `<METHOD> <path>` alias,
+  with the class or router prefix folded in — `@Controller("orders")` plus
+  `@Get(":id")` is `GET /orders/:id`. A mount from another file (`app.use`,
+  `include_router`, `register_blueprint`, Django `include`) is applied when the
+  card is read. `ctx "GET /orders/:id"` and `ctx OrdersController.find` both
+  answer.
+- A URL whose prefix is built at run time (`BASE + "/p"`) matches by its tail.
+  Two routes that match one URL are `AMBIGUOUS`, with both listed. **The graph
+  still never guesses.** `ROUTE` is a new state word beside `LOCAL`, `IMPORT`
+  and `UNIQUE`.
+
+**Four more ways the map used to lose a caller.**
+
+- **An instance alias.** `const svc = new OrderService(); svc.run()` now links to
+  `OrderService.run`. An alias head is a class name, so `router.get` with
+  `router = Router()` is `UNRESOLVED (external)` — not a list of every `get` in
+  the repository.
+- **An inherited member.** `this.ok()` in a subclass finds `Base.ok`, and
+  `super.m()` skips the class's own `m`. The edge carries the state the base
+  class resolved with, plus `inherited`.
+- **A barrel re-export.** An import searches the file it names first, then the
+  files that file re-exports, three deep. A barrel that defines the name itself
+  wins over one that passes it on.
+- **A guess we removed.** A bare call with no receiver (`get("/p")`) no longer
+  resolves to the only method in the repository with that name. In v1.8.1 every
+  supertest `.get(...)` was recorded as a caller of some class method. That was
+  an invented edge, and it is gone.
+
+Measured on two real repositories, v1.8.1 to v1.8.2:
+
+| | django/django | nestjs/nest |
+|---|---|---|
+| confident edges | 65,379 → **72,955** | 7,288 → **9,426** |
+| `UNIQUE` guesses | 23,866 → **6,442** | 1,957 → **275** |
+| `AMBIGUOUS` hints | — | 81,485 → **33,906** |
+| routes found | **656** | **344** |
+| first build | 12.5 → 13.7 s | 3.1 → 4.0 s |
+
+**Five more languages.** Ruby, Rust, Kotlin, Vue and Svelte single file
+components (the `<script>` block, at the file's own line numbers) and C / C++.
+The measurement that matters is how much of a real repository the parser could
+not finish: rubocop **2.4%**, tokio **0.3%**, ktor **1.4%**, primevue **0.5%**,
+sveltejs/svelte **0%**, abseil-cpp **1.7%**, redis **4.5%**.
+
+**Borrowed parsers, where your project already has the tool.** Python already
+used the `ast` of a Python on PATH. TypeScript and JavaScript now use your own
+`node_modules/typescript`, and Go uses the `go` on PATH. ORC still has zero
+dependencies, the record names the rung that read it (`extractor:
+typescript@5.9.3`), and a failure falls back file by file. `ORC_GRAPH_NO_BORROW=1`
+forces the heuristic everywhere.
+
+> **This one missed its gate and ships anyway, on the maintainer's call.** The
+> gate was a 10-point rise in the share of calls resolved with confidence. It
+> measured **+1.0** on nestjs/nest, **−0.3** on vuejs/core and **−0.3** on hugo.
+> The gate measured the wrong thing: that share is held down by calls into
+> packages outside the repository, which no parser can resolve. What did move is
+> INVENTED edges — `UNIQUE` guesses fell 36–40% and `IMPORT` facts rose. The
+> borrow is more correct, not more complete. It costs +0.24 s (TypeScript) and
+> +0.70 s (Go) on a one-file update. There is no new config key, on purpose.
+
+**Fewer round trips.**
+
+- **`orc graph ctx … --source [N]`** appends the target's own lines to the card
+  (80 by default, 200 at most), charged to the same budget. The card and the
+  range arrive in one call.
+- **`orc graph ctx --for-slice <files…>`** prints only the OUTSIDE view of each
+  declared file: who calls into it and from which line, who imports it without
+  calling, which routes it answers, which tests cover it. No symbol table. An
+  executor reads its own files in full anyway, so a file card repeated what it
+  was about to read — on every later turn of that agent. The outside view is
+  30–51% smaller than the card it replaces.
+- **`orc graph update --notes-pending`** answers the update and the notes batch
+  in one process and one lock.
+- **A card prints one-letter states with a legend only when that is smaller**
+  than the words. A three-row card keeps the words. Always-short made small
+  cards bigger, which is the opposite of the point.
+- **A card that hid nothing prints no footer.**
+
+**The hook learned two more moments.** A shell search (`grep`, `rg`, `git grep`,
+`findstr`, `Select-String`, `ag`, `ack`) is the same question as a Grep, and now
+gets the same answer. And with `orc config set code_graph_hooks on,read`, a
+whole-file read of a file with many symbols gets one line naming its six most
+reached symbols and their ranges, so the NEXT read can ask for a range. **The
+read always runs.** The hook never blocks a tool call and never rewrites one.
+
+**Doc notes — the author's own sentence, for free.** The parser now takes the
+first sentence of a docstring, a JSDoc block, a `///` run or a `#` block and
+prints it on the card as `doc <sentence> (parser · current)`. It costs no model
+tokens, and it is re-extracted with the body, so it cannot go stale on its own.
+A comment can still lie, so a CURRENT model note outranks it: the order is
+current note → doc → stale note.
+
+> **We expected this to cover most of a repository. It does not.** The plan said
+> more than 60% of symbols would carry a doc. Measured: **19.9%** on django
+> (30.6% of non-test source), **7.1%** on nest (9.0%). The extractor is right —
+> the comments are simply not there. The number in this file is the measured
+> one.
+
+**`orc graph gain` — what the map put in, and an estimate of what it kept out.**
+Every read appends one line to a local ledger. The command adds them up and
+keeps three kinds of knowing apart, because merging them produces a number
+nobody can check:
+
+- **paid** — the tokens the graph put into a context. Recorded, exact.
+- **avoided** — what searching would have cost for the same question. **An
+  estimate**, always a range, never one number.
+- **measured** — `--measured` reads your own runs with the graph on against your
+  runs with it off, and prints nothing until there are three of each.
+
+It never prints a percent of a session, it never blocks a read, and `orc stats`
+reports `graph: null` when there is no ledger — never a confident zero.
+
+**`orc graph map` — the question you ask before you know a file name.** It ranks
+every indexed file by how much of the repository's own call and import traffic
+flows through it, and prints the top files with their most important symbols and
+line ranges, inside a token budget. `--focus src/orders/service.js,createOrder`
+re-ranks the whole repository around those files or names; it never filters it.
+A test file ranks lower (by ten), a file whose every symbol is private ranks
+lower (by half), and an edge is weighted by the square root of its call count, so
+one import used in a loop does not outrank ten separate callers. **Rank is a hint
+about where to look first, never proof that a file matters to this change** — the
+card says so itself.
+
+> **`map` is wired to PLANNING only, and that was a measurement, not a
+> preference.** The gate was three answerable planning calls per run. Replaying
+> real transcripts measured **0.39** (16 sweeps over 41 main windows), so the
+> plan's own fallback applied and the analyst and `/orc-quick` wiring was
+> removed again. The honest caveat: those transcripts drive lanes over a
+> fourteen-file toy app, where a planner has nothing to sweep. It will be
+> re-measured on a real repository.
+
+**A one-symbol card is about twice as fast.** Working out who calls a symbol used
+to mean parsing the whole index. The resolution cache is now also written as
+shards, one file per name prefix, and a one-symbol `ctx` reads only the shards it
+needs. On django: **881 → 480 ms** for the whole command, **361 → 50 ms** for the
+work inside the process. The floor is Node's own start-up, about 300 ms on the
+test machine.
+
+The shards answer exactly what the full index answers, **or they decline**. 577
+cards on django and nest were compared with and without them: **0 different.**
+The fast path steps aside for a path, a URL, a `file:line`, a name that is not
+exactly one symbol, `--for-slice`, a file card and any multi-target call, and
+every answer says which path produced it. The cost is disk: django's shards are
+**30 MB**, taking `.claude/orc/graph` from about 87 MB to about 117 MB. The
+update pays nothing measurable.
+
+**Also in this release**
+
+- **`code_graph_ignore`** — extra paths the graph never indexes, as a
+  comma-separated list of globs (`vendor/**,*.gen.ts`). The engine already
+  skipped `node_modules`, root `dist/` and `build/`, caches, bundles, `.d.ts`
+  and generated files; this adds to that list. A skipped file is reported
+  `excluded` by `orc graph coverage`, never in silence.
+- `code_graph_hooks` gains the value `on,read` (see the hook above). `on` and
+  `off` behave as before.
+- `orc graph gain` also appears on the `orc ui` Knowledge panel and in one ship
+  line, marked an estimate in both places.
+
+**Limits we know about**
+
+- **Fixed since v1.8.1, with its new limit stated:** a caller that reaches a
+  symbol through a URL is now an edge. A caller that reaches it through a job
+  runner, a string dispatch, reflection, or a URL assembled at run time from
+  parts the parser cannot see is still not an edge and never will be. The file
+  still reads as fully parsed, and the card is still silent. **A card's silence
+  is not proof of absence.**
+- TypeScript and Go are exact only where the project has the tool. Everything
+  else is a heuristic, which is why a card can say `coverage partial`.
+- Java, PHP, Swift, Scala and Dart have no borrowed parser. Ruby's own parser
+  (`Prism`) was gated on the heuristic missing more than 5% of a real
+  repository. It missed 2.4%, so it was not built.
+- The status line component compares HEAD with the index. Only
+  `orc graph status` sees uncommitted edits.
+- The graph hook's delivery on `SubagentStart` is confirmed in a live session.
+  The other delivery events are still unconfirmed, and the hook stays silent and
+  free if they never are.
+- **It is still NOT a token optimisation, and that is still measured, not
+  guessed.** `Grep` and `Glob` results are 0.06% of what a session adds to its
+  context, and a perfect locator would save 0.1% of a run. Turn the map on for
+  the cards: what calls what, what a change would touch, where the parser could
+  not finish. `orc graph gain` reports an estimate and says the word "estimate"
+  every time.
+
+**How to check it.** `orc config set code_graph on`, then `orc graph update`,
+then `orc graph map` to see the repository ranked, and
+`orc graph ctx <a route or a function>` to see a card. Run `orc update` in your
+project to get the lane changes.
+
+---
+
 ### v1.8.1 — the guard that only failed on Windows _(2026-09-16)_
 
 **Still on the unscoped `orc` package?** Do this once first - your `orc upgrade`

package/README-id.md

@@ -7,13 +7,13 @@
 *Terima permintaan → pahami → rencanakan → beri nilai → kerjakan paralel → periksa → uji → kirim.*
 
 ![npm](https://img.shields.io/npm/v/%40azure-id%2Forc?style=for-the-badge&color=cb3837&logo=npm)
-![Version](https://img.shields.io/badge/version-1.8.0-blue.svg?style=for-the-badge)
+![Version](https://img.shields.io/badge/version-1.8.2-blue.svg?style=for-the-badge)
 ![License](https://img.shields.io/badge/license-MIT-green.svg?style=for-the-badge)
 ![Node](https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg?style=for-the-badge)
 ![Claude Code](https://img.shields.io/badge/Claude_Code-Skills-purple.svg?style=for-the-badge)
 ![Dependencies](https://img.shields.io/badge/dependencies-zero-lightgrey.svg?style=for-the-badge)
 
-**Versi terbaru: v1.8.0** · diperbarui 16-09-2026 · [daftar perubahan lengkap](CHANGELOG.md)
+**Versi terbaru: v1.8.2** · diperbarui 21-09-2026 · [daftar perubahan lengkap](CHANGELOG.md)
 
 **Ada di npm: [`@azure-id/orc`](https://www.npmjs.com/package/@azure-id/orc)** — `npm i -g @azure-id/orc`
 
@@ -411,30 +411,51 @@ Peta lokal tentang bagaimana kode Anda saling terhubung. **Default-nya mati.**
 ```bash
 orc config set code_graph on          # lane kode membuat dan memakai peta (gratis)
 orc config set code_graph_notes wave  # opsional: catatan satu kalimat (memakai token)
+orc graph map                         # peringkat repositori, sebelum Anda tahu nama berkasnya
 orc graph ctx OrderService.create     # kartu: pemanggil, yang dipanggil, efek SQL/HTTP/env
+orc graph ctx "GET /orders/:id"       # route juga satu simbol
 orc graph changes                     # apa yang diubah diff INI, dan seberapa berisiko
 orc graph cochange src/orders.js      # apa yang biasanya berubah bersama berkas ini
 orc graph coverage src/orders.js      # berapa banyak yang benar-benar dibaca parser
+orc graph gain                        # apa yang dimasukkan peta, dan perkiraan apa yang ditahannya
 ```
 
 - **Strukturnya gratis.** CLI mem-parse kodenya. Tanpa model, tanpa dependency.
   Fungsi, method, class dan handler route (`GET /orders/:id`); middleware yang
   dikirim lewat nama menjadi tautan `used by`.
+- **Bahasanya:** JavaScript, TypeScript, Python, Go, Java, C#, PHP, Ruby, Rust,
+  Kotlin, C / C++, dan blok `<script>` komponen Vue atau Svelte. Jika proyek
+  Anda sudah punya alatnya, ORC meminjamnya dan hasil parse-nya tepat — `ast`
+  milik Python, `node_modules/typescript` milik Anda, dan `go` di PATH. ORC
+  sendiri tetap tanpa dependency. `ORC_GRAPH_NO_BORROW=1` mematikannya.
+- **URL adalah satu tautan.** Test yang memanggil
+  `request(app).get("/orders/search")` adalah pemanggil route itu, dan kartunya
+  menyebutkannya. Begitu juga alias instance
+  (`const svc = new OrderService(); svc.run()`), method warisan (`this.ok()` →
+  `Base.ok`), dan nama yang di-re-export lewat berkas barrel.
 - **Update-nya kecil.** Git sudah menghitung hash setiap file. Hanya file yang
   hash-nya berubah yang di-parse ulang — perubahan dari teman satu tim diperbaiki
   sendiri di preflight berikutnya.
 - **Setiap tautan menyebut seberapa yakin:** `LOCAL`, `IMPORT`, `UNIQUE`,
-  `AMBIGUOUS` (semua kandidat ditulis) atau `UNRESOLVED`. Graf tidak pernah menebak.
+  `ROUTE`, `AMBIGUOUS` (semua kandidat ditulis) atau `UNRESOLVED`. Graf tidak
+  pernah menebak.
 - **Kartu punya batas token.** Kartu tidak pernah melewatinya, dan menyebut apa
-  yang disembunyikan. `--format tree` menulis nama kolom satu kali saja, bukan di
-  setiap baris, dan kembali ke bentuk biasa jika kartunya terlalu kecil.
+  yang disembunyikan. `--source [N]` menambahkan baris milik targetnya ke
+  panggilan yang sama. `--for-slice` hanya mencetak tampak LUAR satu berkas yang
+  memang akan dibaca penuh oleh agent. `--format tree` menulis nama kolom satu
+  kali saja, bukan di setiap baris.
+- **`orc graph map` menjawab "berkas mana yang penting di sini"** sebelum Anda
+  tahu nama berkasnya, di dalam satu batas token. `--focus` menyusun ulang
+  peringkat seluruh repositori di sekitar berkas atau nama yang sudah disebut
+  permintaan Anda. **Peringkat adalah petunjuk tentang di mana harus melihat
+  lebih dulu**, bukan bukti bahwa satu berkas penting untuk perubahan ini.
 - **Graf menunjukkan letak kode. Graf tidak menggantikan membaca kode.** Agent
   tetap membaca rentang barisnya sebelum bertindak. Kepala kartu menulis
   `coverage partial 327-466` jika parser tidak selesai membaca satu berkas —
   **tidak adanya celah yang tercatat bukan bukti bahwa semuanya lengkap.** Kartu
-  juga hanya menulis pemanggil yang MENYEBUT nama simbolnya: pemanggil yang
-  sampai lewat route HTTP atau dispatch lewat string bukan tautan, jadi
-  **diamnya satu kartu bukan bukti bahwa tidak ada apa-apa.**
+  menulis pemanggil yang MENYEBUT nama simbolnya atau yang sampai lewat URL:
+  pemanggil yang sampai lewat job runner atau dispatch lewat string bukan
+  tautan, jadi **diamnya satu kartu bukan bukti bahwa tidak ada apa-apa.**
 - **Setiap jawaban membawa `generation`** — angka yang naik setiap kali peta
   berubah. Kartu yang dikutip lagi nanti tetap bisa ditempatkan pada waktunya.
 - **Peta tetap segar lewat tiga jalan, dan hanya satu yang perlu diingat orang.**
@@ -444,9 +465,11 @@ orc graph coverage src/orders.js      # berapa banyak yang benar-benar dibaca pa
   membangunnya di preflight dan memperbaruinya setelah setiap perubahan. Lane
   lain tidak pernah memanggilnya. **Tidak ada yang berjalan dengan pewaktu dan
   tidak ada yang berjalan di latar belakang.**
-- **Hook itu juga memberi pekerja titik acuan yang tadinya harus dicari sendiri**,
-  dan semua yang diberikannya ditandai sebagai data repositori, bukan perintah.
-  Matikan dengan `orc config set code_graph_hooks off`; petanya tetap bekerja.
+- **Hook itu juga memberi pekerja titik acuan yang tadinya harus dicari sendiri**
+  — untuk Grep, Glob, dan pencarian lewat shell (`grep`, `rg`, `git grep`,
+  `findstr`) — dan semua yang diberikannya ditandai sebagai data repositori,
+  bukan perintah. Matikan dengan `orc config set code_graph_hooks off`; petanya
+  tetap bekerja.
 
 Kontraknya: `templates/skills/_shared/code-graph.md`. Hook-nya:
 `templates/hooks/README.md`.
@@ -457,7 +480,11 @@ Kontraknya: `templates/skills/_shared/code-graph.md`. Hook-nya:
 > Pencari sempurna — setiap pembacaan berkas penuh menjadi pembacaan rentang —
 > akan menghemat **0,1% dari satu sesi**. Nyalakan peta ini karena Anda ingin
 > kartunya: apa memanggil apa, apa yang akan tersentuh oleh satu perubahan, di
-> mana parser tidak selesai. Bukan demi angka.
+> mana parser tidak selesai. Bukan demi angka. `orc graph gain` memakai kejujuran
+> yang sama: apa yang DIMASUKKAN peta itu tercatat, apa yang ditahannya adalah
+> **perkiraan** yang dicetak sebagai rentang, dan angka terukur baru muncul jika
+> proyek Anda sendiri sudah punya tiga run dengan peta menyala dan tiga dengan
+> peta mati.
 
 ## `orc ui` — panel kendali
 
@@ -656,7 +683,8 @@ templates/
 bin/cli.js        pemasang, penyunting pengaturan, penyusun alur, pembaca status
                   pekerjaan, dan separuh pasti dari setiap lane. Setiap pembacaan
                   bisa menjawab --json
-bin/graph*.js     graf kode: penyimpanan, ekstraksi, resolusi saat dibaca, catatan
+bin/graph*.js     graf kode: penyimpanan, ekstraksi, resolusi + cache dan shard-nya,
+                  sinyal, catatan, peta berperingkat, pengukur gain
 bin/webui/        `orc ui` — panel kendali lokal: css/ + js/ + i18n/<bahasa>/ +
                   fixtures/, satu berkas per lapisan dan per panel. Nol dependensi
 bin/mockrun-catalog.js   katalog contoh jalannya (diturunkan dari berkas di disk)
@@ -732,67 +760,58 @@ Bacalah sebagai catatan putaran itu, bukan sebagai audit terkini:
 **Riwayat lengkap: [CHANGELOG.md](CHANGELOG.md)** — atau `orc changelog`, yang
 hanya mencetak yang lebih baru dari versi yang Anda punya.
 
-### v1.8.0 - graf kode: peta kode yang selalu baru _(16-09-2026)_
-
-Lane ORC menghabiskan sebagian besar tokennya untuk mencari: Grep, baca file,
-Grep lagi. Agent berikutnya di wave berikutnya mencari hal yang sama lagi.
-
-**`orc graph` adalah peta lokal tentang bagaimana kode saling terhubung.**
-Default-nya mati: `orc config set code_graph on`.
-
-- **Strukturnya gratis.** CLI mem-parse JavaScript, TypeScript, Python, Go,
-  Java, C# dan PHP — tanpa model. Python memakai parser `ast` miliknya sendiri
-  jika Python 3.8+ terpasang.
-- **Update-nya kecil.** Hanya file yang hash git-nya berubah yang di-parse ulang.
-  Di django/django (3.040 file sumber) build pertama 12 detik, update satu file
-  2,7 detik, dan satu kartu 0,46 detik.
-- **`orc graph ctx | impact | path`** menjawab dengan batas token dan kata status
-  di setiap tautan. Handler route menjadi simbol, dan middleware yang dikirim
-  lewat nama menjadi tautan `used by`. `--format tree` menulis nama kolom satu
-  kali saja — 17–21% lebih sedikit token pada kartu berkas.
-- **Bagian yang mahal kini ditulis sekali.** Mencari siapa yang memanggil satu
-  simbol memakan 437 ms di django/django, setiap kali dibaca. Sekarang dihitung
-  saat peta di-update lalu dibaca kembali: kartu berkas 727 ms → 458 ms, dan
-  `orc graph impact` 631 ms → 397 ms. Simpanan itu TURUNAN — hanya dipakai jika
-  menyebut versi peta yang sekarang, dan menghapusnya hanya menghilangkan
-  kecepatan.
-- **Setiap jawaban membawa `generation`**, dan setiap berkas menyebut berapa
-  banyak yang benar-benar dibaca parser — `full`, `partial` dengan rentang
-  barisnya, atau `skipped`. `orc graph coverage <berkas>` menanyakannya sekaligus.
-- **Tiga jawaban baca-saja yang baru, semuanya gratis:** `orc graph changes`
-  (simbol yang benar-benar disentuh diff ini, dengan pemanggil, test, dan kata
-  risiko yang membawa alasannya sendiri), `orc graph cochange <berkas>` (apa yang
-  biasanya berubah BERSAMA berkas itu, dari riwayat git — bukan ketergantungan),
-  dan `orc graph coverage`.
-- **Catatan bersifat opsional** (`code_graph_notes: wave | end`). Satu agent
-  Sonnet 4.6 menulis satu kalimat per fungsi yang berubah. Catatan hanya
-  ditampilkan selama isi fungsinya tidak berubah.
-- **Peta tetap segar lewat tiga jalan, dan hanya satu yang perlu diingat orang.**
-  Satu pembacaan memperbaiki berkas yang akan dijawabnya. Hook yang terpasang
-  memperbarui peta saat satu pekerja selesai, dan memberi pekerja titik acuan
-  yang tadinya harus dicari sendiri. Dan setiap lane kode tetap membangunnya di
-  preflight. `/orc-quick` tetap hanya membaca `log_dir`. **Tidak ada yang
-  berjalan dengan pewaktu dan tidak ada yang berjalan di latar belakang.**
-- **Semua yang diterima pekerja dari graf ditandai sebagai data repositori, bukan
-  perintah.** Nama simbol berasal dari repositori Anda, jadi ORC memperlakukannya
-  sebagai teks. Isi berkas tidak pernah dikirimkan — hanya nama, path dan
-  rentang baris.
-- **Juga:** delapan kunci pengaturan, dua temuan `orc doctor`, kartu graf kode di
-  `orc ui`, dan komponen status line `graph`.
-
-**Batas yang kami tahu.** TypeScript dibaca dengan pencocokan pola, bukan dengan
-compiler TypeScript. `x = new Service(); x.run()` tampil sebagai `AMBIGUOUS`.
-Pemanggil yang tidak pernah menyebut nama simbolnya — tes route HTTP, penjalan
-job — bukan tautan, jadi baca kartu sebagai titik awal, bukan sebagai daftar
-lengkap yang akan terdampak.
-**Ini bukan optimasi token, dan itu sudah diukur.** Pencarian hanya 0,06% dari
-yang ditambahkan satu sesi ke konteksnya; pencari sempurna pun hanya menghemat
-0,1% dari satu run. Peta ini tidak memakai token model untuk dibangun dan waktu
-baca di atas nyata — nyalakan demi kartunya, bukan demi penghematan.
+### v1.8.2 - peta yang menemukan apa yang tidak bisa ditemukan grep _(21-09-2026)_
+
+v1.8.0 merilis graf kode dengan satu lubang yang sudah diketahui: kartu hanya
+menulis pemanggil yang MENYEBUT nama simbolnya, jadi test yang sampai ke satu
+route lewat URL bukan pemanggil dan kartunya diam soal itu. **Sekarang URL
+adalah satu tautan** — begitu juga alias instance
+(`const svc = new OrderService(); svc.run()`), method warisan, dan nama yang
+di-re-export lewat barrel. Panggilan tanpa penerima tidak lagi diarahkan ke
+satu-satunya method di repositori yang namanya sama; tebakan itu adalah tautan
+karangan dan sudah dihapus. Di django, tautan yang pasti naik dari 65.379 ke
+72.955 dan tebakan `UNIQUE` turun dari 23.866 ke 6.442.
+
+**Lima bahasa baru** — Ruby, Rust, Kotlin, C / C++ dan blok `<script>` komponen
+Vue atau Svelte. **Parser pinjaman** jika proyek Anda sudah punya alatnya:
+`node_modules/typescript` milik Anda dan `go` di PATH bergabung dengan `ast`
+milik Python. ORC sendiri tetap tanpa dependency.
+
+**Lebih sedikit bolak-balik.** `ctx --source [N]` menambahkan baris target ke
+kartunya. `ctx --for-slice` hanya mencetak tampak luar satu berkas yang memang
+akan dibaca penuh oleh agent — 30–51% lebih kecil dari kartu yang digantikannya.
+`update --notes-pending` menjawab keduanya dalam satu panggilan. Hook sekarang
+juga menjawab pencarian lewat shell, dan `code_graph_hooks on,read` menyebut
+enam simbol paling banyak dijangkau di satu berkas besar supaya pembacaan
+berikutnya bisa meminta satu rentang saja.
+
+**`orc graph map`** memberi peringkat repositori sebelum Anda tahu nama
+berkasnya, di dalam satu batas token, dengan `--focus`. Peringkat adalah
+petunjuk tentang di mana harus melihat lebih dulu, bukan bukti. **Kartu satu
+simbol kira-kira dua kali lebih cepat** — cache resolusinya sekarang dipecah
+menjadi shard, jadi django turun dari 881 ke 480 ms, dan shard menjawab persis
+sama dengan indeks penuh atau menolak menjawab (577 kartu dibandingkan, 0
+berbeda).
+
+**`orc graph gain`** melaporkan apa yang dimasukkan peta — tercatat — dan
+perkiraan, selalu sebagai rentang, tentang apa yang ditahannya. Angka tunggal
+tidak pernah dicetak, dan penghematan yang tidak bisa dibuktikan tidak pernah
+diklaim.
+
+**`code_graph_ignore`** adalah kunci baru: glob tambahan yang tidak pernah
+diindeks graf.
+
+Dua gate di rilis ini tidak tercapai, dan CHANGELOG menyebutkannya lengkap
+dengan angkanya: parser pinjaman tetap dirilis atas keputusan pemelihara
+walaupun gate tingkat kepastian mengukur +1,0 / −0,3 / −0,3, dan `orc graph map`
+hanya dihubungkan ke perencanaan karena pengukuran ulang transkrip mendapat 0,39
+panggilan perencanaan yang bisa dijawab per run, terhadap gate tiga.
 
 <details>
-<summary><strong>Rilis sebelumnya</strong> — 116 rilis, hanya judulnya. Teks lengkapnya (dalam bahasa Inggris) ada di <a href="CHANGELOG.md">CHANGELOG.md</a>.</summary>
+<summary><strong>Rilis sebelumnya</strong> — 118 rilis, hanya judulnya. Teks lengkapnya (dalam bahasa Inggris) ada di <a href="CHANGELOG.md">CHANGELOG.md</a>.</summary>
 
+- **v1.8.1** — the guard that only failed on Windows · _2026-09-16_
+- **v1.8.0** — the code graph: a map of the code that stays fresh · _2026-09-16_
 - **v1.7.1** — the rules card now reaches the agent · _2026-09-14_
 - **v1.7.0** — the rules that keep the slop out · _2026-09-13_
 - **v1.6.0** — the rule that can finally say no · _2026-09-07_