feat(config): T-1276 — every invocation is a job, carried ambiently

Streaming as a decorator, first half. Each invocation of reach gets an id and
every event it emits is tagged with it, which is what will let a detached run's
log be read back and what correlates the lines of a run that streamed for nine
minutes. No command signature changed and no command imports core.jobs — that
is the point, per the D-263 amendment: a command must not know jobs exist,
because the alternative is call-site discipline wearing a different hat.

A ContextVar rather than a module global. A global is correct only until
something runs two invocations in one process — which a test harness or a
future batch verb does immediately, and which would then interleave two jobs'
events under one id with nothing reporting an error.

The job context is the OUTERMOST wrapper, and it has to be. @logged emits from
its finally and @handle_errors emits its verdict while unwinding, so a context
established inside either would already be reset by the time the two most
important events are written — leaving them the only untagged lines in the log,
and they are precisely the ones a detached run gets read back for.

Fixed in passing: the job id used local time while every event's ts is UTC, so
an id read 155327 beside its own first log line reading 13:53:27. Two hours
apart reads as a logging bug every time someone correlates them by eye.

New conformance invariant — nothing outside core/ may import core.jobs. My
first version of it inspected only the module path, so it missed
`from tooling.core import jobs`, where the name is in the import LIST and which
is the form anyone would actually write. It passed while checking nothing.
Rewritten to catch all three reachable forms and then verified by committing a
real violation, which it named by file and line.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

tooling/test_conformance.py

@@ -103,6 +103,43 @@ def check_transport_isolation(failures: list[str]) -> None:
             )
 
 
+def check_jobs_stay_ambient(failures: list[str]) -> None:
+    """No domain imports core.jobs — job identity is the decorator's business.
+
+    The whole point of carrying the job ambiently is that a command never has to
+    open one, tag one, or remember to close one. The moment a domain imports
+    `core.jobs`, that has become call-site discipline again, and it will fail the
+    same way: one command forgets and its output loses correlation silently.
+
+    core/ is exempt — command.py and console.py are where the ambience is
+    implemented.
+    """
+    for path in _package_files():
+        if path.parent.name == "core":
+            continue
+        source = path.read_text(encoding="utf-8")
+        tree = ast.parse(source, filename=str(path))
+        for node in ast.walk(tree):
+            # Three forms reach the same module and all three must be caught:
+            #   from tooling.core import jobs        -> module, names
+            #   from tooling.core.jobs import ...    -> module
+            #   import tooling.core.jobs             -> names
+            hit = False
+            if isinstance(node, ast.ImportFrom) and node.module:
+                hit = node.module == "tooling.core.jobs" or (
+                    node.module == "tooling.core"
+                    and any(alias.name == "jobs" for alias in node.names)
+                )
+            elif isinstance(node, ast.Import):
+                hit = any(alias.name == "tooling.core.jobs" for alias in node.names)
+            if hit:
+                failures.append(
+                    f"[jobs] {path.relative_to(REPO_ROOT)}:{node.lineno} imports core.jobs — "
+                    "job identity is ambient and belongs to @command; a command that "
+                    "touches it has reintroduced the call-site discipline this replaced"
+                )
+
+
 def check_single_output_path(failures: list[str]) -> None:
     """(2) Nothing prints but console."""
     for path in _package_files():
@@ -229,6 +266,7 @@ def main() -> int:
 
     failures: list[str] = []
     check_transport_isolation(failures)
+    check_jobs_stay_ambient(failures)
     check_single_output_path(failures)
     check_commands_decorated(failures)
     check_errors_name_a_remedy(failures)