@aistastudio/myc 0.3.6 → 0.3.9

package/README.md

@@ -1,8 +1,11 @@
 # myc
 
 A local, fast task-and-memory layer for coding agents: a task queue, an oplog of
-facts and decisions, and hybrid (lexical + vector) search over the project's
-memory — with no network calls and no mandatory LLM key.
+facts and decisions, hybrid (lexical + vector) search over the project's
+memory, and a built-in code index — with no network calls of its own and no
+mandatory LLM key. The network is reached only when you ask: `myc models
+fetch`, `myc code fetch`, `myc version --check` (or `MYC_UPDATE_CHECK=1`, a
+background version check at most once a day from `init` and `wire`).
 
 Agents forget. `myc` is the part that doesn't: decisions survive context
 compaction, work survives process death, and both survive being moved between
@@ -11,11 +14,15 @@ machines through plain git.
 Design docs live in `docs/design/` (start with `00-brief.md`); the measurements
 quoted below are reproducible from `bench/` and `scripts/`.
 
-**Site: <https://aistastudio.github.io/myc/>** — the same measurements as charts,
-in English and Russian, with the command that reproduces each number printed
-next to it. Source in `site/`; `bun run site/build.ts` re-checks every figure
-against the measurement artefacts in this repository and refuses to build on a
-mismatch.
+**Site: <https://aistastudio.github.io/myc/>** — every capability with the
+release it arrived in and a command that shows it, the roadmap, and the
+measurements as charts, in English and Russian, with the command that
+reproduces each number printed next to it. It is the one source of numbers:
+`bun run site/build.ts` checks every figure on the site against the measurement
+artefacts in this repository, the figures in this README and in the Russian one
+against the site's `site/measurements.json`, and every `myc` command and flag
+on the site and in both READMEs against this build's `--help`; a mismatch fails
+the build.
 
 ## Requires Bun — this is not fine print
 
@@ -30,20 +37,23 @@ Install Bun: https://bun.sh
 Installation is one command:
 
 ```bash
-bun install -g @aistastudio/myc   # 3.20 MB, 10 files, no models pulled at install
-myc --version                     # myc 0.3.6 (schema 1)
+bun install -g @aistastudio/myc   # 3.41 MB compressed, 12.57 MB unpacked, 13 files; no models pulled
+myc --version                     # myc 0.3.9 (schema 1)
 ```
 
-It runs on macOS and Linux; on Windows, use WSL.
+It runs on macOS and Linux. On Windows, use WSL and install Bun and myc inside
+it: the `myc` launcher does not start in cmd or PowerShell, and an npm install
+on Windows says so.
 
 The embedding model is **not** downloaded during install. Semantic search is
 opt-in and explicit: `myc models fetch` (129 MB, ~7 s). Until then search is
-lexical and says so.
+lexical and says so on every answer (`WARN degraded.embeddings`). The grammars
+for the code index are fetched the same way, once: `myc code fetch`.
 
 To run the newest code instead of the published release, build from source:
 
 ```bash
-git clone <repo> && cd myc
+git clone https://github.com/aistastudio/myc && cd myc
 bun install
 bun run build          # produces a single binary: dist/myc
 ./dist/myc --version
@@ -55,18 +65,40 @@ writing a config that silently won't start.
 
 ## Quick start
 
+Two commands set a project up; the rest is the loop an agent lives in. (From a
+source build, `./dist/myc` instead of `myc`.)
+
 ```bash
-./dist/myc init                     # .myc/ + SQLite + migrations in this repo
-./dist/myc wire                     # hooks for Claude Code / Codex / opencode / Kimi
-./dist/myc wire --scope user        # the same for agents in git worktrees (Claude Code's user layer)
-./dist/myc ready                    # what can be picked up right now
-./dist/myc remember "why X, not Y"  # record a fact or decision
-./dist/myc recall "how retrieval works"
-./dist/myc prime                    # session context packet (agents call it)
-./dist/myc doctor                   # schema, counters, hooks — says "don't know" where it doesn't
+myc init                     # .myc/ + SQLite + migrations in this repo
+myc wire                     # hooks + MCP for Claude Code, Codex, opencode and Kimi
+myc ready --claim            # take the next task
+myc show <id>                # all that is known about it
+myc close <id>
+myc remember "why X, not Y"  # record a fact or decision
+myc recall "how retrieval works"
+myc prime                    # session context packet (agents call it)
+myc code fetch               # grammars for this repo's languages, once
+myc code index               # symbols, callers, code search
+myc doctor                   # schema, counters, hooks — says "don't know" where it doesn't
 ```
 
-Full command list: `./dist/myc --help`.
+Full command list: `myc --help`; details of each: `myc <command> --help`.
+
+## Wiring agents
+
+`myc wire` writes only its own files in full and merges JSON configs node by
+node with a `.myc.bak` alongside; `CLAUDE.md` is never touched. Running it twice
+changes nothing. Everything past the plain `wire` is opt-in:
+
+```bash
+myc wire --dry-run              # show every change, write nothing
+myc wire --agents claude,codex  # only some of the agents
+myc wire --status-line          # + myc's status line under Claude Code's prompt
+myc wire --queue-hook           # + heavy commands take turns (below)
+myc wire --agents-md            # + the myc block in AGENTS.md
+myc wire --scope user           # the same for agents in git worktrees (Claude Code's user layer)
+myc unwire                      # remove what wire put in
+```
 
 **Agents in git worktrees.** `myc wire` writes into the project:
 `.claude/settings.json`, `.mcp.json`. An agent that orca starts in a git
@@ -94,15 +126,15 @@ journal, not in our command, and gets the same stdin on every redraw, never
 waited on: orca takes a line whose command mentions its
 `agent-hooks/claude-statusline.sh` for its own and removes it when it
 uninstalls (a foreign line it leaves alone), so ours never carries the word
-`claude-statusline`. A
-project with its own myc line keeps it, and that line hands the input to the
-same recorded line. If another tool replaces the user line after wire, `myc
-doctor --hooks` says so; `myc wire --scope user --status-line` puts ours back
-and makes the new line the previous one, and `myc unwire --scope user` puts the
-previous line back byte for byte. `myc doctor --hooks` checks the whole user
-layer against the journal: myc's hook entries and rules still in
-`~/.claude/settings.json`, the helpers exactly what this build writes (a stale
-one is named with the build that wrote it), the status line, the MCP server.
+`claude-statusline`. A project with its own myc line keeps it, and that line
+hands the input to the same recorded line. If another tool replaces the user
+line after wire, `myc doctor --hooks` says so; `myc wire --scope user
+--status-line` puts ours back and makes the new line the previous one, and `myc
+unwire --scope user` puts the previous line back byte for byte. `myc doctor
+--hooks` checks the whole user layer against the journal: myc's hook entries and
+rules still in `~/.claude/settings.json`, the helpers exactly what this build
+writes (a stale one is named with the build that wrote it), the status line, the
+MCP server.
 
 ## Heavy commands take turns
 
@@ -144,14 +176,14 @@ Code `PreToolUse` hook that rewrites a heavy Bash command into
 `myc run -- <the same command>` before it runs. Heavy means a full test run or a
 build: `bun test` with no paths, `bun run build` / `typecheck`, `npm` / `pnpm` /
 `yarn` `test` and `build`, `cargo test` / `build`, `go test ./...`, `pytest`
-with no paths, `make`. A targeted `bun test path/file.test.ts`, a command already
+with no paths, `make`. A targeted `bun test <path>`, a command already
 under `myc run`, a background one and a nested one pass untouched.
 `MYC_QUEUE_HEAVY` replaces the list (`+…` adds to it, `off` turns the hook off).
 It is opt-in: `wire` without the flag writes no such hook, and `unwire` removes
 it. It is cheap, because it runs on every Bash call: a command that is not heavy
 is let through by the host's own shell without starting bun or node — 3.4 ms at
-the median and 4.3 ms at p99 in the run of 2026-09-11, against 30 ms for the
-prime hook (`bun test packages/cli/src/hooks/queue-hook.multiprocess.test.ts`).
+the median and 4.3 ms at p99 in the run of 2026-09-11, against the prime hook's
+30 ms p99 budget (`bun test packages/cli/src/hooks/queue-hook.multiprocess.test.ts`).
 
 **`myc run` is not a way around permissions.** It runs whatever it is given, so
 a queued command goes through without a question only when your own rules would
@@ -159,26 +191,139 @@ let the original command through — `Bash(bun test:*)` keeps `bun test` silent
 under the queue as well. Otherwise Claude Code asks, and the question shows the
 whole command; a deny or ask rule on the original command still holds. The same
 goes for a `myc run -- <cmd>` an agent types itself. For the same reason `wire`
-no longer writes the broad `Bash(myc:*)`: it allows myc's subcommands one by
-one, and `run`, `statusline --then`, `wire` and `unwire` ask.
+does not write the broad `Bash(myc:*)`: it allows myc's subcommands one by one,
+and `run`, `statusline --then`, `wire` and `unwire` ask.
+
+## Code intelligence
+
+Code intelligence is built in, and it is the same engine the alternatives use:
+tree-sitter, with grammars fetched on demand rather than shipped. Symbols,
+callers and code search work for TypeScript, TSX, JavaScript (js, jsx, mjs,
+cjs) and Python — the languages myc has definition rules for. The grammar
+package holds 36; a language is added as a pair, a rule and a catalog entry,
+so a grammar that would yield no symbols is never offered. Every other file
+still gets `code grep`, anchors and staleness.
+
+`myc code fetch` downloads exactly the grammars this repository's files need,
+checked by sha256 — the only step that goes to the network; indexing never does,
+and a language whose grammar is missing is skipped and named. `myc code index`
+builds the index, incrementally: a repeat run over an unchanged tree reads
+nothing, and after that the index is refreshed in the background. These read it,
+from the CLI and over MCP alike:
+
+```
+myc code symbol <name>   where it is defined, and what knowledge is anchored there
+myc callers <name>       who calls it; --direction out, --depth all
+myc code search "…"      by meaning, when you do not know the name
+myc code grep "<lit>"    exhaustive, every occurrence; --in <path> narrows it
+myc code map             orientation: directory clusters, their hubs, who depends on them
+myc skeleton <file>      the file's API, and how many times cheaper that was than reading it
+```
+
+The file list is git's own (`git ls-files`, so `.gitignore` applies; a tree
+without git is walked, and the command says so). On top of any list,
+secret-named files are never indexed, whatever `.gitignore` says: `.env` and
+`.env.*` (templates like `.env.example` are indexed), `*.pem`, `*.key`,
+keystores, private SSH keys, `.npmrc`, `.netrc` and other credential files —
+`code index` counts them without naming them, and `code grep` refuses to read one.
+
+**Nested repositories and git worktrees.** A workspace can be an ecosystem: a
+root that is a git repository with independent repositories inside it (not
+submodules). It has one code index, built from the root — one row per file,
+paths like `messaging-server/server/src/x.ts`. From inside a nested
+repository every code command answers from that repository's part of the
+root index, with paths relative to the repository you are in; from the root
+the answers do not change. `myc code index` run inside a nested repository
+refreshes its part of the root index instead of building a second copy of the
+same files. The index also keeps itself fresh: after any myc command, when its
+last run is older than 15 minutes (`MYC_CODE_INDEX_PERIOD_MS`), one background
+`code index` per workspace is queued and runs detached at low priority, never
+delaying the command; the status line and the code commands say when it is
+refreshing, queued or stale. A git worktree — even one
+outside the workspace tree — is answered from the index of the main checkout:
+there is no index per branch. When the worktree is on another commit, or has
+uncommitted changes to tracked files, every answer carries
+`WARN code_index.worktree_divergent` naming both branches, because lines and
+spans may not match your files. `code grep` reads the worktree's files (the
+line numbers are yours, the owning symbols come from the index); `skeleton`
+shows the main copy's declarations when your copy differs from what the index
+saw, and says so. When nothing covers the repository, the hint is the command
+for the workspace root (`myc -C <root> code index`), not one that would build a
+duplicate. Anchors set from the root and from inside a repository are stored
+under different keys; `code symbol` reads both.
+
+Anchors tie knowledge to a span and follow the code as it moves; that half is
+language-agnostic and was verified on Python as well as TypeScript.
+
+## Migration from beads
+
+```bash
+cd <beads-project>
+myc init
+myc import-beads --dry-run   # count what would come over, change nothing
+myc import-beads             # collects the snapshot itself: bd export --include-memories
+```
+
+Run it again later and it is a sync, not a second copy: fields changed in beads
+(status, priority, labels, close reason, parent, blockers) are applied as normal
+graph changes, and local myc edits are never silently overwritten — one-sided
+local changes are kept and named, two-sided ones are named as conflicts and left
+alone. A snapshot file moves the same between machines:
+`bd export --include-memories > snapshot.json`, then
+`myc import-beads snapshot.json`.
+
+**It is real, not a demo.** A working project imported into an empty workspace
+in 889 ms: 796 tasks, 972 dependencies, 265 notes, 41 memories — with unknown
+issue types carried over verbatim and named, and out-of-range priorities
+clamped and named, instead of one odd row aborting the import. Those numbers are
+from the first release (0.1.1, 2026-09-07), and that run silently dropped the
+export's comments while reporting every note as imported; it was found the next
+day on a real project and fixed in 0.2.0 (`git show aac5d1f`). What the import
+carries now:
+
+- comments, into the node's thread with their authors; unknown top-level
+  fields are named instead of dropped (0.2.0);
+- acceptance criteria and design, into the task body between managed markers,
+  and the source's own dates, author and owner (0.3.3);
+- statuses myc has no name for, such as `deferred`, as `blocked` with the
+  original word kept — never as `open` (0.3.3);
+- sub-repositories of a shared workspace, each with its own repository reach;
+  an empty source is a refusal with a hint, not a silent zero (0.3.3).
+
+On that same graph both ready queues now return the same 152 tasks. They did
+not always: myc used to offer 195 against beads' 144, because beads inherits
+blockers down the parent chain and myc looked only at a task's own. Those 51
+were inside a still-blocked epic and beads was right to hide them;
+`memory-atcm254ry6c7` is closed, `anc_blockers` is materialised by trigger, and
+the queue now says `281 blocked (51 through an ancestor)` rather than quietly
+offering them.
 
 ## What makes it different
 
-**Speed is a constraint, not an optimisation.** Every hot path has a budget
-enforced in CI; a p95 regression over 15% fails the build. Measured on 100 000
-nodes, 2026-09-07, darwin-arm64-14 (`bun run scripts/bench-latency.ts`):
+**Speed is a constraint, not an optimisation.** Every hot path has a budget,
+and a budget test makes three kinds of claims: structural (the query plan, the
+prefilter), relative (the healthy path against a deliberately degraded rival,
+measured alternately, so the hardware cancels out) and absolute. On every push
+CI checks the first two. The absolute budgets and the 15% p95 regression line
+are calibrated on darwin-arm64-14 and bind there; CI and the nightly run use
+GitHub's 4-core runners, which are not that machine and are declared
+uncalibrated (`MYC_BENCH_ABSOLUTE=0`), so there the absolute numbers are printed
+and logged, not enforced. Measured on 100 000 nodes on 2026-09-11,
+darwin-arm64-14, myc 0.3.6, not re-measured since
+(`bun run scripts/bench-latency.ts`):
 
 | operation | p99 | budget |
 |---|---|---|
-| `prime` (session context) | 0.755 ms | 30 ms |
-| read | 0.012 ms | 3 ms |
-| search | 10.354 ms | 25 ms |
-| write | 0.460 ms | 5 ms |
-| cold start | 23.820 ms | 60 ms |
+| `prime` (session context) | 0.608 ms | 30 ms |
+| read | 0.010 ms | 3 ms |
+| search | 8.215 ms | 25 ms |
+| write | 0.327 ms | 5 ms |
+| cold start | 21.337 ms | 60 ms |
 
 **Ranking is measured, not asserted.** Two labelled corpora with graded
 relevance, each containing a *control group that gets worse* when the feature
-works — so a gain cannot be manufactured by shaping the corpus:
+works — so a gain cannot be manufactured by shaping the corpus (both re-measured
+2026-09-10):
 
 - boosts (priority, freshness, layer): MRR@10 **0.520 → 0.867** (`bench/boost-eval.ts`)
 - graph expansion to 2 hops: MRR@10 **0.193 → 0.422** (`bench/graph-eval.ts`),
@@ -205,6 +350,29 @@ episode sess-5jh8je4g050m saved (265 B)
 NEXT     myc show sess-5jh8je4g050m · myc ready --claim
 ```
 
+**Decisions pulled from a compaction are candidates, not facts.** The same hook
+lifts "we decided / because" lines out of the transcript and stores them as
+candidates (`state pending_review`); recall, search, prime and MCP do not
+return them until someone confirms. `prime` names them in its footer —
+`N pending review hidden — myc review` — and `myc review` lists them, this
+session's first, for a person or an agent to settle. Confirming makes the
+candidate knowledge the way a new note is born (embedding and absorb
+classification queued); rejecting retracts it with the reason kept in the node.
+An agent does the same through MCP: `myc_ready` with `review` lists,
+`myc_update` with `confirm` or `reject` settles; the web knowledge base puts
+the two buttons on the candidate's row.
+
+```
+$ myc review
+PENDING REVIEW 2 · 1 in this session's prime · 1 from other sessions · session 3f9c21aa
+$ myc review confirm memory-6k2x…
+$ myc review reject memory-9x1q… --reason "restates the task, not a decision"
+```
+
+A retracted note — a rejected candidate among them — is out of every retrieval
+path, not only replaced versions: superseded, retracted and cancelled are one
+list shared by recall, prime and the status line.
+
 **A status line with what the agent cannot see.** `myc wire --status-line`
 puts one line under Claude Code's prompt — how full the context is, the task
 queue, the code index, the project's memory, and how many of this session's
@@ -233,17 +401,20 @@ project-wide.
 $ MYC_SESSION_ID=s1 myc recall "retries"        $ MYC_SESSION_ID=s2 myc recall "retries"
 … prj  project note: retries use jitter          … prj  project note: retries use jitter
 … ses  session note: retries back off…           … ses* session note: retries back off…
-3 of 3 · bm25 only                               3 of 3 · bm25 only · 2 from other sessions
+3 of 3 · bm25 only · …                           3 of 3 · bm25 only · … · 2 from other sessions
 ```
 
 **Memory has three independent axes**, and the surface says what it hid:
 tier (project vs personal), session reach, repository reach. `prime` prints
-`N notes from other repositories hidden` rather than quietly narrowing results.
+`N from other sessions hidden` and `N notes from other repos hidden` rather
+than quietly narrowing results.
 
 **Degradation is loud.** No silent fallbacks: when the vector branch is
 unavailable the output says so and marks the answer as lexical-only; when a
 budget is exceeded it is named with the number. The invariant is that a
-degraded answer must never be indistinguishable from a healthy one.
+degraded answer must never be indistinguishable from a healthy one. With
+`--strict` a degraded answer also exits with code 6 instead of 0, and the
+`WARN` line still prints.
 
 **Multi-machine sync through plain git, merged per field.** Only the oplog is
 committed. Two machines editing the same node converge: one changes title and
@@ -251,91 +422,48 @@ priority, the other title and tags — after exchange both show the later title,
 the first machine's priority and the second's tags. Nothing is lost to
 last-writer-wins over whole records.
 
-**Migration from beads is real, not a demo.** A working project imported in
-889 ms: 796 tasks, 972 dependencies, 265 notes, 41 memories — with unknown
-issue types carried over verbatim and named, and out-of-range priorities
-clamped and named, instead of one odd row aborting the import. On that same
-graph both queues now return the same 152 tasks. They did not always: myc used
-to offer 195 against beads' 144, because beads inherits blockers down the
-parent chain and myc looked only at a task's own. Those 51 were inside a
-still-blocked epic and beads was right to hide them; `memory-atcm254ry6c7` is
-closed, `anc_blockers` is materialised by trigger, and the queue now says
-`281 blocked (51 through an ancestor)` rather than quietly offering them.
-
 **Guards are proved by mutation.** Every refusal and every invariant is
 accompanied by a mutation that removes it; a guard whose removal breaks no test
-is treated as absent.
-
-## Roadmap
+is treated as absent. The full suite: 3625 pass / 0 fail / 16 skip
+(`bun test`, 2026-09-11).
 
-Numbers are closed/total subtasks per milestone (`myc show <epic-id>`), as of
-2026-09-10. Done and not-done are shown the same way on purpose. Totals grow
-when work uncovers work: M0 went 33 → 39 because measuring it found four real
-defects, not because the plan changed.
-
-| milestone | status |
-|---|---|
-| **M0** core and tasks | 40 / 43 |
-| **M0.5** self-hosting (myc developed through myc) | **4 / 4 — closed** |
-| **M1** memory | 22 / 24 |
-| **M2** semantics | 20 / 22 |
-| **M7** human interface (board, cards, threads, routing panel, status line) | **15 / 15** |
-| **M3** code intelligence | 6 / 10 |
-| **M4** team: `myc serve`, ACL, network sync, Postgres, containers | 3 / 14 |
-| **M5** swarm self-learning: routing by cost and outcome | 0 / 13 |
-| **M6** distillation | 0 / 7 |
-
-What that means in practice: **today myc is a single-user local tool over files
-in git.** There is no server, no ACL and no team mode. Those are designed
-(`docs/design/03…`, `04…`, `05…`) and tracked, not implemented.
+## What myc does
 
-Code intelligence is built in, and it is the same engine the alternatives use:
-tree-sitter, with grammars fetched on demand rather than shipped. Symbols,
-callers and code search work for TypeScript, TSX, JavaScript (js, jsx, mjs,
-cjs) and Python — the languages myc has definition rules for. The grammar
-package holds 36; a language is added as a pair, a rule and a catalog entry,
-so a grammar that would yield no symbols is never offered. Every other file
-still gets `code grep`, anchors and staleness. `myc code index` builds it — on this repository,
-826 files and 3 949 symbols in 904 ms — and four commands read it:
+Tasks with leases, dependencies and blockers inherited down the parent chain;
+memory that survives compaction and is scoped by session and repository;
+ranked hybrid search; the code index above; hooks and MCP for four agents;
+the machine-wide queue for heavy commands; the status line; import from beads;
+a local web interface (`myc viz`: graph, queue, board, cards, search, health —
+edits go through the same write path as the CLI); git worktrees and nested
+repositories; sync through git and a `doctor` that compares claims with a
+recount.
 
-```
-myc code symbol <name>   where it is defined, and what knowledge is anchored there
-myc callers <name>       who calls it; --direction out, --depth all
-myc code search "…"      by meaning, when you do not know the name
-myc code grep "<lit>"    exhaustive, every occurrence; --in <path> narrows it
-myc skeleton <file>      the file's API — 26× cheaper than reading it
-```
+The full list — each capability with the release it arrived in and a command
+that shows it on your machine, every command checked against this build's
+`--help` when the site is built — is on the site:
+<https://aistastudio.github.io/myc/#features>.
 
-The file list is git's own (`git ls-files`, so `.gitignore` applies; a tree
-without git is walked, and the command says so). On top of any list,
-secret-named files are never indexed, whatever `.gitignore` says: `.env` and
-`.env.*` (templates like `.env.example` are indexed), `*.pem`, `*.key`,
-keystores, private SSH keys, `.npmrc`, `.netrc` and other credential files —
-`code index` counts them without naming them, and `code grep` refuses to read one.
+## Roadmap
 
-**Nested repositories and git worktrees.** A workspace can be an ecosystem: a
-root that is a git repository with independent repositories inside it (not
-submodules). It has one code index, built from the root — one row per file,
-paths like `messaging-server/server/src/x.ts`. From inside a nested
-repository every code command answers from that repository's part of the
-root index, with paths relative to the repository you are in; from the root
-the answers do not change. `myc code index` run inside a nested repository
-refreshes its part of the root index instead of building a second copy of the
-same files, and so does the background refresh. A git worktree — even one
-outside the workspace tree — is answered from the index of the main checkout:
-there is no index per branch. When the worktree is on another commit, or has
-uncommitted changes to tracked files, every answer carries
-`WARN code_index.worktree_divergent` naming both branches, because lines and
-spans may not match your files. `code grep` reads the worktree's files (the
-line numbers are yours, the owning symbols come from the index); `skeleton`
-shows the main copy's declarations when your copy differs from what the index
-saw, and says so. When nothing covers the repository, the hint is the command
-for the workspace root (`myc -C <root> code index`), not one that would build a
-duplicate. Anchors set from the root and from inside a repository are stored
-under different keys; `code symbol` reads both.
+Where each milestone stands — closed/total subtasks of every epic in the
+project's own tracker, and every task still open inside it, with no dates — is
+on the site: <https://aistastudio.github.io/myc/#planned>. The counts are not
+typed in: `bun run site/roadmap.ts` reads them from myc before a release, and
+the site build refuses a plan that describes a task the tracker no longer has
+open.
+
+In short: the core, memory, semantics and the human interface (M0–M2, M7) are
+done or nearly done, and so is English output for every CLI and MCP line; code
+intelligence (M3, including the built-in replacement for graft) and the
+heavy-command queue have shipped, with tasks still open; the team milestone
+(M4: `myc serve`, ACL, network sync, Postgres) is mostly design; swarm
+self-learning (M5: routing by cost and outcome, with a shared pool of agent
+statistics) and distillation (M6) have not started.
 
-Anchors tie knowledge to a span and follow the code as it moves; that half is
-language-agnostic and was verified on Python as well as TypeScript.
+What that means in practice: **today myc is a single-user local tool over files
+in git.** There is no server, no ACL and no team mode. Those are designed
+(`docs/design/03-interfaces-and-integration.md`,
+`docs/design/04-swarm-learning-and-routing.md`) and tracked, not implemented.
 
 ## Syncing between machines
 

package/bin/myc.js

@@ -28,7 +28,8 @@
  * после интерпретатора ОДНИМ аргументом. -S есть в GNU coreutils ≥ 8.30 и в
  * env macOS/BSD. На Windows такой shebang не исполним: шим `bun add -g` берёт
  * `-S` за программу, а cmd-shim npm -S понимает, но Bun на Windows не
- * открывает /dev/null — myc там только через WSL (говорит preflight.js).
+ * открывает /dev/null — myc там только через WSL (говорят preflight.js и
+ * refusal() ниже, если этот файл всё же запустили под Node).
  * Запуск МИМО shebang (`bun …/myc.js`) флагов не получает; второй рубеж для
  * `myc run` — callerEnv в src/commands/run.ts.
  */
@@ -82,31 +83,44 @@ function resolveVec0() {
   }
 }
 
+/**
+ * Текст отказа — по-английски, как весь вывод CLI (эпик memory-rc2s0m1e9kpz).
+ * На Windows совет «поставьте Bun» был бы ложным: shebang там не исполним и с
+ * Bun (см. шапку и preflight.js), поэтому совет там один — WSL, тем же текстом,
+ * что в рамке preflight.js.
+ */
 function refusal() {
   const node = process.versions.node;
   const lines = [
     "",
     "  myc requires Bun — it cannot run on Node.",
     "",
-    `  myc запущен под Node ${node}, а он работает только на Bun: хранилище`,
-    "  построено на встроенном в Bun `bun:sqlite`, которого в Node нет.",
+    `  This is Node ${node}, and myc runs only on Bun: its storage is built`,
+    "  on Bun's built-in `bun:sqlite`, which Node does not have.",
     "",
   ];
-  if (bunOnPath()) {
+  if (process.platform === "win32") {
+    lines.push(
+      "  myc runs on macOS and Linux; on Windows use WSL.",
+      "  The `myc` launcher will not start in cmd or PowerShell, with or without Bun.",
+      "      wsl --install",
+      "  Then, inside WSL: install Bun and @aistastudio/myc there.",
+      "",
+    );
+  } else if (bunOnPath()) {
     lines.push(
-      "  Bun у вас установлен — запускайте через него:",
-      "      bun x myc <команда>",
-      "  либо переустановите пакет средствами bun:",
+      "  Bun is installed — run myc through it:",
+      "      bun x myc <command>",
+      "  or reinstall the package with bun:",
       "      bun add -g @aistastudio/myc",
       "",
     );
   } else {
     lines.push(
-      "  Установите Bun (>= 1.3.0) и повторите:",
+      "  Install Bun (>= 1.3.0) and try again:",
       "      curl -fsSL https://bun.sh/install | bash        # macOS, Linux, WSL",
-      '      powershell -c "irm bun.sh/install.ps1 | iex"    # Windows',
       "",
-      "  После установки: myc --version",
+      "  Then: myc --version",
       "",
     );
   }

package/bin/preflight.js

@@ -38,14 +38,15 @@ if (process.platform === "win32") {
     ]),
   );
 } else if (typeof process.versions.bun !== "string" && !bunOnPath()) {
+  // По-английски, как весь вывод CLI (эпик memory-rc2s0m1e9kpz).
   process.stderr.write(
-    frame("@aistastudio/myc установлен, но запускаться пока не будет", [
-      "myc работает только на Bun (хранилище на bun:sqlite).",
-      "Bun в системе не найден.",
+    frame("@aistastudio/myc is installed, but it will not start yet", [
+      "myc runs only on Bun (its storage is bun:sqlite).",
+      "Bun was not found on this system.",
       "",
       "  curl -fsSL https://bun.sh/install | bash",
       "",
-      "После этого: myc --version",
+      "Then: myc --version",
     ]),
   );
 }