@@ -1054,11 +1054,19 @@ name then answers `jscpd: command not found` with the tool sitting right there.
 uses.** Every one is `argv = ["${python}", "${dir}/<helper>.py", ...]` or
 `["node", "...cjs", ...]`, and the helper spawns `jscpd`/`pmd`/`php`/`deptry`/
 `ruff` itself, one process further in — where the tools that actually go missing
-on Windows go missing. `sensors/spawn.Spawner._runnable` still resolves a bare
-`argv[0]`, since off Windows it names the very file the spawn's own search would
-have reached; only a **bare** name is resolved, because a path (`${python}`,
-`${dir}/helper.py`) is read against the directory the command runs in, and every
-argument after the first is an argument whatever it looks like.
+on Windows go missing. A **bare** `argv[0]` that names a declared `command`
+detector is resolved through that detector — the loader puts it in
+`Part.detectors` (`named_tools._bare_program`) and `command_text._program`
+substitutes the file — so the bare spelling and `${detector:<name>}` agree on
+the same search paths, and a binstub in the project's `bin` is found by either
+spelling or by neither. `Spawner._runnable` still resolves a bare `argv[0]`,
+but only as the fallback for names nobody declared: off Windows such a name
+is the very file the spawn's own search would have reached, and a path
+(`${python}`, `${dir}/helper.py`) is read against the directory the command
+runs in, while every argument after the first is an argument whatever it looks
+like. The typescript plugin's `argv = ["node", ...]` parts now resolve `node`
+through its own declaration — the same file the fallback found, and a machine
+without node fails by name rather than at the spawn.
 
 The other process gets there by **naming the tool in the recipe**:
 `${detector:<name>}` (`sensors/named_tools.py`) expands to the file
 
@@ -119,6 +119,11 @@ declares, and a name declared `node-module`, are both refused as the config load
 the ordinary missing-tool failure — the sensor is never spawned, and the notice
 names the tool it needed, without your script having to say so.
 
+A bare `argv[0]` that names a declared `command` detector is resolved to that
+same file, along the detector's own `search_paths`, and fails the same way when
+it is not installed; only a name no plugin declares is left for the spawn to
+look up along the default path.
+
 Hand that file to a bundled script rather than looking the tool up again inside
 it. Every shipped sensor that names a tool passes it as the script's first
 argument:
 
@@ -236,7 +236,7 @@ root keys — it describes the plugin, not the whole run:
 | `language`     | The language this plugin **declares**. A plugin is not a language: its name need not match, several plugins can declare the same language, and the runner stamps this onto the plugin's findings. `generic` declares none. |
 | `sensors`      | An ordered list of the sensor names the plugin runs. |
 | `transformers` | An ordered list of the plugin's own transformers, applied to its sensors' concatenated findings before the result joins the larger run. |
-| `detectors`    | The external tools this plugin's sensors reach for, each a `{ name, kind, install, search_paths }` table: what to look for, how to look for it (`command` — on `PATH`; `node-module` — a package `node` resolves from the project, for one read as a library rather than spawned), the command that installs it, and — optionally — `search_paths`, a list of directories under the project that a `command` is looked for in ahead of the default path (`node_modules/.bin`, `.venv/bin`, then `PATH`). A project never declares these: it names the plugins it runs, and what each of those needs installed is the plugin's to say. |
+| `detectors`    | The external tools this plugin's sensors reach for, each a `{ name, kind, install, search_paths }` table: what to look for, how to look for it (`command` — on `PATH`; `node-module` — a package `node` resolves from the project, for one read as a library rather than spawned), the command that installs it, and — optionally — `search_paths`, a list of directories under the project that a `command` is looked for in ahead of the default path (`node_modules/.bin`, `.venv/bin`, then `PATH`) — however the recipe names it, `${detector:<name>}` or a bare `argv[0]`. A project never declares these: it names the plugins it runs, and what each of those needs installed is the plugin's to say. |
 
 ```toml
 # habit_hooks_ruby/config.toml
 
@@ -8,7 +8,9 @@
   and with no shell in the way a quote character would simply become part of
   the filename. It is also the only form that runs where there is no POSIX
   shell: on Windows ``bash`` is usually the WSL launcher, which answers from
-  another filesystem entirely.
+  another filesystem entirely. Its first element may name a tool as a bare
+  name, resolved to that tool's file exactly as ``${detector:<name>}`` is
+  (``named_tools``).
 * ``command = "..."`` is text for ``bash -c``, and buys syntax a list cannot
   carry — the ``ruff`` and ``eslint`` sensors pipe their tool through ``jq`` —
   at the price of a shell to read it, which is why a platform without one
@@ -92,13 +94,24 @@ def _argv_form(part: Part, files: list[str], config_path: Path | None) -> list[s
         "${args}": part.args,
         "${config}": _config_arguments(config_path),
     }
+    elements = part.argv or []
+    program = [_program(part, elements[0])] if elements else []
     return [
         argument
-        for element in part.argv or []
+        for element in [*program, *elements[1:]]
         for argument in _element_arguments(part, element, lists)
     ]
 
 
+def _program(part: Part, element: str) -> str:
+    """The program element as the file this project runs for it, where a name
+    this run's plugins declared resolved to one (``named_tools``): a bare name
+    is looked up again by whatever spawns it, along paths that know nothing of
+    the detector's own. Anything else keeps the element it was."""
+    file = part.detectors.get(element)
+    return element if file is None else file
+
+
 def _element_arguments(
     part: Part, element: str, lists: dict[str, list[str]]
 ) -> list[str]:
 
@@ -32,9 +32,10 @@ class Part:
     # A sensor's own discovery globs: when set, the run's scope is narrowed to
     # this subset for this sensor alone. ``None`` means "the whole scope".
     files: list[str] | None = None
-    # The file this project runs for each tool the recipe names with
-    # ``${detector:<name>}``, or ``None`` where that tool is not installed
-    # (``named_tools``). Only the tools it names, never its plugin's others.
+    # The file this project runs for each tool the recipe names — with
+    # ``${detector:<name>}``, or as the bare program an ``argv`` spells — or
+    # ``None`` where that tool is not installed (``named_tools``). Only the
+    # tools it names, never its plugin's others.
     detectors: dict[str, str | None] = field(default_factory=dict)
 
     @property
 
@@ -9,7 +9,8 @@
 and on Windows that lookup adds ``.exe`` and nothing else, where npm installs
 every Node tool as a ``.cmd`` shim.
 
-Only the tools a recipe actually names are resolved for it. A part answers for
+Only the tools a recipe actually names are resolved for it: a placeholder, or
+the bare program an ``argv`` spells as its first element. A part answers for
 what it reaches for and never for its plugin's other tools, or a project missing
 a tool no sensor of that plugin names would fail the sensors that never wanted
 it.
@@ -32,6 +33,7 @@
 
 
+import os
 import re
 import shlex
 from collections.abc import Callable
@@ -101,7 +103,9 @@ def files_for(part: Part, kind: str, tools: DeclaredTools) -> dict[str, str | No
     """The file this project runs for each tool ``part`` names, ``None`` if absent.
 
     A name that can never stand for a file at all stops the run here, naming the
-    part, why, and the config line that stops running it.
+    part, why, and the config line that stops running it. The bare program an
+    ``argv`` spells is a name too, resolved the same way and refused nothing:
+    a program nobody declared is the spawn's own to look up.
     """
     named = _names_in(part)
     for name in named:
@@ -111,7 +115,11 @@ def files_for(part: Part, kind: str, tools: DeclaredTools) -> dict[str, str | No
                 f"{kind} {part.name!r} names ${{detector:{name}}}, {unusable} — "
                 f"{switch_off(kind, part.name)}"
             )
-    return {name: tools.file_for(name) for name in named}
+    files = {name: tools.file_for(name) for name in named}
+    program = _bare_program(part)
+    if program and program not in files and COMMAND_KIND in tools.kinds_of(program):
+        files[program] = tools.file_for(program)
+    return files
 
 
 def spelled_plainly(part: Part, text: str) -> str:
@@ -144,6 +152,13 @@ def _names_in(part: Part) -> list[str]:
     return list(dict.fromkeys(DETECTOR.findall(recipe)))
 
 
+def _bare_program(part: Part) -> str | None:
+    """The program an ``argv`` recipe spells as a bare name, if it spells one."""
+    if part.argv is None or os.path.dirname(part.argv[0]):
+        return None
+    return part.argv[0]
+
+
 def _why_no_file_for(name: str, tools: DeclaredTools) -> str | None:
     """Why ``name`` can never stand for a file to spawn, or ``None`` when it can."""
     kinds = tools.kinds_of(name)
 
@@ -85,7 +85,9 @@ def run(
     def _runnable(self, argv: list[str], tools: Sequence[str]) -> list[str]:
         """``argv`` with its program named by the file this project runs for it.
 
-        A bare command name is the only thing in question. Left as a name it is
+        A bare command name is the only thing in question, and one a detector
+        declared arrives already resolved to its file (``command_text``) — this
+        lookup is the fallback for names nobody declared. Left as a name it is
         looked up by whatever the spawn uses, which on Windows is not the
         lookup the tool was cleared by — so this asks the one that cleared it
         (``project_paths.tool_executable``) and hands the spawn its answer.
 
@@ -0,0 +1,108 @@
+"""A bare ``argv[0]`` that names a declared tool, and the file it then runs.
+
+``${detector:<name>}`` is one way a recipe names a tool; a bare program name is
+the other, and the authoring guide promises both
+(``docs/authoring-plugins.spec.md``). The bare spelling used to be looked up
+along the default path alone, whatever the tool's detector declared — so a
+binstub installed only under the project's ``bin`` was cleared by the setup
+(``missing_tools`` asks the detector's own search paths) and then not found by
+the run, the very disagreement ``project_paths.tool_executable`` exists to
+prevent. A bare name this run's plugins declared is resolved to the same file
+the placeholder spelling stands for; a name nobody declared keeps the lookup
+the spawn always made.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from bare_machine import project_with_no_tools
+from detector_declarations import declaring
+from executable_stub import write_stub
+from plugin_fixture import one_sensor
+
+from habit_hooks.project_paths import tool_executable
+from habit_hooks.scope import Scope
+from habit_hooks.sensors.model import Part
+
+BUNDLER = (
+    '{ name = "rubocop", kind = "command", install = "gem install rubocop", '
+    'search_paths = ["bin"] }'
+)
+
+
+def _argv(project: Path, part: Part) -> list[str]:
+    """The argv spawning ``part`` in ``project`` would carry."""
+    return Execution(project_dir=project, scope=Scope(files=[]))._expand(part)
+
+
+def _run(project: Path, part: Part) -> object:
+    """What running ``part`` over one file comes to."""
+    scope = Scope(files=["a.rb"])
+    return Execution(project_dir=project, scope=scope).run_sensors([part])
+
+
+def test_a_bare_program_is_looked_for_along_the_search_path_its_detector_names(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The bare spelling of a name is resolved exactly as ``${detector:<name>}``
+    is: the same detector, the same search paths, the same file."""
+    project = project_with_no_tools(tmp_path, monkeypatch)
+    write_stub(project / "bin", "rubocop")
+    part = one_sensor(project, 'argv = ["rubocop", "--json"]', declaring(BUNDLER))
+
+    argv = _argv(project, part)
+
+    assert Path(argv[0]).parent == project / "bin"
+    assert Path(argv[0]).stem == "rubocop"
+    assert argv[1:] == ["--json"]
+
+
+def test_a_bare_program_only_the_detector_could_find_is_the_file_that_runs(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The whole gap: the default lookup cannot find the program, and the run
+    still executes the detector's file — a clean run, where the bare name alone
+    was the missing command the notice would have named."""
+    project = project_with_no_tools(tmp_path, monkeypatch)
+    write_stub(project / "bin", "rubocop")
+    part = one_sensor(project, 'argv = ["rubocop", "--json"]', declaring(BUNDLER))
+
+    assert tool_executable("rubocop", project) is None
+
+    run = _run(project, part)
+
+    assert run.notices == []
+    assert run.findings == []
+
+
+def test_a_bare_program_declared_and_absent_fails_by_name(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A declared tool the project has not got is the everyday missing tool,
+    whichever spelling named it — answered before the spawn, naming what to
+    install."""
+    project = project_with_no_tools(tmp_path, monkeypatch)
+    part = one_sensor(project, 'argv = ["rubocop", "--json"]', declaring(BUNDLER))
+
+    run = _run(project, part)
+
+    assert run.notices == [
+        "habit-sensors: sensor 's' needs the 'rubocop' command, which is not "
+        "installed — install it, or disable the sensor with [sensors.s] "
+        "disabled = true"
+    ]
+
+
+def test_a_bare_program_nobody_declared_keeps_the_name_it_spelled(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Only a declared name is resolved through its detector: ``node`` here is
+    nobody's, and the recipe keeps the name it spelled for the spawn to look
+    up as it always did."""
+    project = project_with_no_tools(tmp_path, monkeypatch)
+    part = one_sensor(project, 'argv = ["node", "h.cjs"]', declaring(BUNDLER))
+
+    assert _argv(project, part)[0] == "node"
@@ -9,9 +9,10 @@
 to install and how to stop running it in the meantime.
 
 Every recipe here is the shape a shipped sensor has — a helper of its own, handed
-the tool it is to spawn — and never the tool as ``argv[0]``. That one fails at the
-spawn whatever the loader knew, so it would prove nothing; a helper handed a name
-it cannot run prints its clean ``[]`` and the run believes it, which is the
+the tool it is to spawn — and never the tool as ``argv[0]``: a declared one is
+refused before the spawn (``test_a_bare_program_names_its_tool``) and an
+undeclared one fails at it, so neither would prove anything; a helper handed a
+name it cannot run prints its clean ``[]`` and the run believes it, which is the
 false-clean these cases are about.
 """