code-context-control 2.128.1__tar.gz → 2.129.0__tar.gz

{code_context_control-2.128.1 → code_context_control-2.129.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.128.1
+Version: 2.129.0
 Summary: Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.128.1 → code_context_control-2.129.0}/cli/c3.py

@@ -91,7 +91,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.128.1"
+__version__ = "2.129.0"
 
 
 def _compress_file_cli(compressor, path, mode="smart", **kw):

{code_context_control-2.128.1 → code_context_control-2.129.0}/cli/mcp_server.py

@@ -734,7 +734,10 @@ async def c3_read(file_path: str, symbols: Any = None, lines: Any = None,
     """READ source, or MAP a file when called with only file_path (read-only, plan-mode safe).
     file_path: single or comma-separated. symbols: names as the map prints them (Class.method ok).
     lines: int, [start,end], or list of ranges. No symbols/lines = one line per symbol with
-    signature and [La-Lb] range at ~10% of the file's tokens; then read the symbols you need."""
+    signature and [La-Lb] range at ~10% of the file's tokens; then read the symbols you need.
+    Paths OUTSIDE the project root are read too (sibling repo, extra working dir, installed
+    package source): tagged [c3-read:external], served from a transient record, never added
+    to this project's index or related facts. Access Guard rules still apply there."""
     path_err = validate_file_path(file_path)
     if path_err:
         return f"[c3_read:error] {path_err}"

{code_context_control-2.128.1 → code_context_control-2.129.0}/cli/tools/_helpers.py

@@ -147,6 +147,40 @@ _HEREDOC_MARKERS = {
 _GHOST_NAMES = _PYTHON_TYPE_NAMES | _HEREDOC_MARKERS
 
 
+EXTERNAL_TAG = "[c3-read:external]"
+
+
+def external_banner(path: str) -> str:
+    """The one line every outside-the-root response opens with.
+
+    One definition so c3_read and c3_compress cannot drift apart on it.
+    """
+    return (f"{EXTERNAL_TAG} {path} — outside the project root; served but "
+            f"not indexed, and absent from this project's search, map cache "
+            f"and related facts.\n")
+
+
+def project_key(full, project_path) -> tuple[str, bool]:
+    """``(key, external)`` for an already-resolved-or-not path.
+
+    Inside the root the key is the project-relative posix path — how
+    file_memory, the edit ledger and related facts all address a file.
+    Outside it there is no such key, so the absolute posix path stands in and
+    ``external`` tells the caller to serve from a transient record rather than
+    the index (docs/file-map.md § Outside the root).
+
+    This used to be a bare ``relative_to`` whose ValueError escaped as a tool
+    crash. It is not a containment check and must not become one: Access Guard
+    already rules on the absolute canonical path, and it runs before this.
+    """
+    resolved = Path(full).resolve()
+    try:
+        rel = resolved.relative_to(Path(project_path).resolve())
+        return str(rel).replace("\\", "/"), False
+    except ValueError:
+        return resolved.as_posix(), True
+
+
 def validate_file_path(file_path: str) -> str | None:
     """Return an error message if file_path looks like a ghost-file path, else None.
 

{code_context_control-2.128.1 → code_context_control-2.129.0}/cli/tools/ci.py

@@ -385,6 +385,15 @@ def handle_ci(action: str, job: str, run_id: str, allow_foreign: bool,
                 f"            runs Linux jobs in a container "
                 f"({ci_act.DEFAULT_IMAGE}), real `uses:` actions included",
             ]
+            if state.get("warning"):
+                lines.append(f"            WARNING: {state['warning']}")
+            # An image that is present locally is still not proof act can pull
+            # it: act sends the stored registry credential where the CLI sends
+            # none, so an expired token fails a public pull (issue #173). Say
+            # so rather than let `available` read as a guarantee.
+            lines.append("            a runner failure before any step runs is "
+                         "reported as a container-setup failure, not as 0 "
+                         "parsed failures")
         else:
             lines += ["  act       UNAVAILABLE", f"            {state['reason']}"]
         lines += [

{code_context_control-2.128.1 → code_context_control-2.129.0}/cli/tools/compress.py

@@ -11,9 +11,10 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 
 from cli.tools import _grants
-from cli.tools._helpers import finalize_with_tokens, show_token_ratios
+from cli.tools._helpers import external_banner, finalize_with_tokens, project_key, show_token_ratios
 from core import count_tokens
 from services import access_guard
+from services.file_map import render_map
 
 #: Every mode name c3_compress ever accepted, and what to say about it now.
 RETIRED_MODES = {
@@ -35,7 +36,8 @@ def deprecation_line(requested: str) -> str:
 
 
 def map_detail(svc, rel: str, requested_mode: str, *, cache_hit: bool,
-               symbols: int = 0, fallback: str = "") -> dict:
+               symbols: int = 0, fallback: str = "", record: dict = None,
+               external: bool = False) -> dict:
     """Telemetry `detail` for a map served from file_memory (C0, 2.120.0).
 
     backend names the code path, parser the extractor that built the record
@@ -43,13 +45,15 @@ def map_detail(svc, rel: str, requested_mode: str, *, cache_hit: bool,
     whether the record was already fresh. `symbols` is how many the caller
     asked for and `fallback` why a read served a map instead of source.
     `deprecated_mode` (2.122.0) is set when a retired mode name was asked for.
+    `record` is a caller-supplied transient record (an outside-the-root read,
+    which is deliberately absent from file_memory) and `external` flags it.
     Flat so telemetry.aggregate_tool_telemetry can fold it without a schema.
     """
-    record = None
-    try:
-        record = svc.file_memory.get(rel)
-    except Exception:
-        record = None
+    if record is None:
+        try:
+            record = svc.file_memory.get(rel)
+        except Exception:
+            record = None
     if not isinstance(record, dict):
         record = None
     detail = {
@@ -65,6 +69,9 @@ def map_detail(svc, rel: str, requested_mode: str, *, cache_hit: bool,
         detail["fallback"] = fallback
     if requested_mode not in ("map", "read"):
         detail["deprecated_mode"] = requested_mode
+    if external:
+        detail["backend"] = "transient"
+        detail["external"] = True
     return detail
 
 
@@ -136,20 +143,37 @@ def _compress_single(file_path: str, requested: str, note: str, svc, finalize) -
     if not full.exists():
         return ("[file_map:error] not found. To create a new file use "
                 "c3_edit(file_path=..., old_string='', new_string=<content>).")
-    rel = str(full.resolve().relative_to(Path(svc.project_path).resolve())).replace("\\", "/")
-    # C0 measurement: was the record already fresh before this call?
-    cache_hit = not svc.file_memory.needs_update(rel)
-    res = _build_map(svc, rel)
+    resolved = full.resolve()
+    rel, external = project_key(resolved, svc.project_path)
+    # Outside the root the map comes from a transient record — same parser,
+    # never written to an index keyed by project-relative path
+    # (docs/file-map.md § Outside the root). c3_read does the same thing; the
+    # two map surfaces must not disagree about where a file may live.
+    banner = external_banner(rel) if external else ""
+    if external:
+        ext_record = svc.file_memory.build_transient_record(resolved, key=rel)
+        cache_hit = False
+        body = (render_map(ext_record, max_tokens=svc.file_memory.MAP_TOKEN_BUDGET)
+                if ext_record
+                else f"[file_map] Could not build map for {rel} — unreadable.")
+    else:
+        ext_record = None
+        # C0 measurement: was the record already fresh before this call?
+        cache_hit = not svc.file_memory.needs_update(rel)
+        body = _build_map(svc, rel)
+    res = banner + body
     raw_tokens = None
     map_tokens = 0
     try:
         raw_text = full.read_text(encoding="utf-8", errors="replace")
         raw_tokens = count_tokens(raw_text)
         map_tokens = count_tokens(res)
-        if map_tokens >= raw_tokens and not res.startswith("[file_map]"):
+        if map_tokens >= raw_tokens and not body.startswith("[file_map]"):
             # A map that costs more than the file is worth nothing
             # (docs/file-map.md § Small files).
-            res = f"[compress:{file_path}] whole file — smaller than its map\n" + raw_text
+            res = (banner
+                   + f"[compress:{file_path}] whole file — smaller than its map\n"
+                   + raw_text)
             map_tokens = count_tokens(res)
         summary = "map"
     except Exception:
@@ -162,7 +186,8 @@ def _compress_single(file_path: str, requested: str, note: str, svc, finalize) -
         res, summary,
         raw_tokens=raw_tokens, optimized_tokens=map_tokens or None,
         response_tokens=map_tokens,
-        detail=map_detail(svc, rel, requested, cache_hit=cache_hit))
+        detail=map_detail(svc, rel, requested, cache_hit=cache_hit,
+                          record=ext_record, external=external))
 
 
 def _compress_batch(paths: list, requested: str, note: str, svc, finalize) -> str:
@@ -195,10 +220,17 @@ def _compress_batch(paths: list, requested: str, note: str, svc, finalize) -> st
                 full = Path(fp)
             if not full.exists():
                 return fp, None, None, None, "not found"
-            rel = str(full.resolve().relative_to(
-                Path(svc.project_path).resolve())).replace("\\", "/")
-            res = svc.file_memory.get_or_build_map(
-                rel, max_tokens=svc.file_memory.MAP_TOKEN_BUDGET)
+            resolved = full.resolve()
+            rel, external = project_key(resolved, svc.project_path)
+            if external:
+                record = svc.file_memory.build_transient_record(resolved, key=rel)
+                res = external_banner(rel) + (
+                    render_map(record, max_tokens=svc.file_memory.MAP_TOKEN_BUDGET)
+                    if record
+                    else f"[file_map] Could not build map for {rel} — unreadable.")
+            else:
+                res = svc.file_memory.get_or_build_map(
+                    rel, max_tokens=svc.file_memory.MAP_TOKEN_BUDGET)
             try:
                 raw_tok = count_tokens(full.read_text(encoding="utf-8", errors="replace"))
                 map_tok = count_tokens(res)

{code_context_control-2.128.1 → code_context_control-2.129.0}/cli/tools/read.py

@@ -7,10 +7,11 @@ from pathlib import Path
 from typing import Any
 
 from cli.tools import _grants
-from cli.tools._helpers import finalize_with_tokens, maybe_related_facts
+from cli.tools._helpers import external_banner, finalize_with_tokens, maybe_related_facts, project_key
 from cli.tools.compress import map_detail
 from core import count_tokens
 from services import access_guard
+from services.file_map import render_map
 
 
 def _coerce_list(val: Any) -> list[str] | None:
@@ -175,7 +176,21 @@ def handle_read(file_path: str, symbols: Any = None, lines: Any = None,
     if not full.exists():
         return f"[read:error] File not found: {file_path}"
 
-    rel_path = str(full.resolve().relative_to(Path(svc.project_path).resolve())).replace("\\", "/")
+    # A path outside the project root is READ, not refused (docs/file-map.md
+    # § Outside the root). The root was never the control here: Access Guard
+    # ruled above and its rules match the absolute canonical path as well as
+    # the project-relative one, so the builtin denies still cover an outside
+    # file; and the PreToolUse hook stands down outside the root, so native
+    # Read already went there unimpeded. Refusing only pushed the agent off
+    # the budgeted, guarded tool onto the unbudgeted one.
+    #
+    # What the root DOES decide is indexing. file_memory is keyed by
+    # project-relative path and feeds the text index, the map cache and
+    # prune_stale, so an outside file is served from a transient record and
+    # never written into this project's store.
+    resolved = full.resolve()
+    rel_path, external = project_key(resolved, svc.project_path)
+    banner = external_banner(rel_path) if external else ""
 
     if full.is_dir():
         # A directory maps to one line per file, budgeted
@@ -184,7 +199,9 @@ def handle_read(file_path: str, symbols: Any = None, lines: Any = None,
         budget = DEFAULT_MAX_TOKENS
         if isinstance(lines, int) and not isinstance(lines, bool) and lines > 0:
             budget = lines
-        text, dir_detail = render_directory_map(svc, rel_path, max_tokens=budget)
+        text, dir_detail = render_directory_map(svc, rel_path, max_tokens=budget,
+                                                external=external)
+        text = banner + text
         tok = count_tokens(text)
         if finalize is None:
             return text
@@ -228,15 +245,56 @@ def handle_read(file_path: str, symbols: Any = None, lines: Any = None,
     # Ensure file_memory index is fresh.
     # When the watcher is running, it handles updates in the background —
     # only force-update if file_memory has no record at all (first access).
-    try:
-        watcher_active = (hasattr(svc, "watcher") and svc.watcher._observer.is_alive())
-        if watcher_active:
-            if not svc.file_memory.get(rel_path):
+    # An outside-the-root file is never indexed; it gets a transient record
+    # instead, built lazily below.
+    if not external:
+        try:
+            watcher_active = (hasattr(svc, "watcher") and svc.watcher._observer.is_alive())
+            if watcher_active:
+                if not svc.file_memory.get(rel_path):
+                    svc.file_memory.update(rel_path)
+            elif svc.file_memory.needs_update(rel_path):
                 svc.file_memory.update(rel_path)
-        elif svc.file_memory.needs_update(rel_path):
-            svc.file_memory.update(rel_path)
-    except Exception:
-        pass
+        except Exception:
+            pass
+
+    _ext_cache = []
+
+    def _ext_record():
+        """The transient record for an outside file — same parser and schema
+        as an indexed one, never persisted (docs/file-map.md § Outside the
+        root).
+
+        Built at most once, and only where a map or a symbol lookup actually
+        needs it: a `lines=[a,b]` read must not pay for a full parse of the
+        file it is slicing two lines out of, which is the whole reason the
+        large-file bounds exist.
+        """
+        if not external:
+            return None
+        if not _ext_cache:
+            _ext_cache.append(
+                svc.file_memory.build_transient_record(resolved, key=rel_path))
+        return _ext_cache[0]
+
+    def _file_map(max_tokens=None) -> str:
+        """The map, from the project index or from the transient record."""
+        if not external:
+            return svc.file_memory.get_or_build_map(rel_path, max_tokens=max_tokens)
+        record = _ext_record()
+        if not record:
+            return f"[file_map] Could not build map for {rel_path} — unreadable."
+        return render_map(record, max_tokens=max_tokens)
+
+    def _map_cached() -> bool:
+        return False if external else not svc.file_memory.needs_update(rel_path)
+
+    def _facts() -> str:
+        # Facts are project knowledge keyed by project-relative path; an
+        # outside file has none, and matching one by basename would be a lie.
+        if external:
+            return ""
+        return maybe_related_facts(svc, rel_path, top_k=3, context="read")
 
     raw_text = full.read_text(encoding="utf-8", errors="replace")
     # EOL-normalize exactly the way c3_edit's matcher does (\r\n and \r → \n),
@@ -256,7 +314,9 @@ def handle_read(file_path: str, symbols: Any = None, lines: Any = None,
         return _full_tok_cache[0]
 
     if symbols:
-        matches = svc.file_memory.get_symbol_ranges(rel_path, symbols, return_matches=True)
+        matches = svc.file_memory.get_symbol_ranges(rel_path, symbols,
+                                                    return_matches=True,
+                                                    record=_ext_record())
 
         # Check for ambiguity
         disambiguation_msgs = []
@@ -292,7 +352,7 @@ def handle_read(file_path: str, symbols: Any = None, lines: Any = None,
             ranges.append(m["range"])
 
         if '<main>' in symbols or '<globals>' in symbols:
-            record = svc.file_memory.get(rel_path)
+            record = _ext_record() or svc.file_memory.get(rel_path)
             if record and "sections" in record:
                 covered = set()
 
@@ -318,29 +378,31 @@ def handle_read(file_path: str, symbols: Any = None, lines: Any = None,
                 ranges.extend(main_ranges)
 
     if not ranges and symbols:
-        map_cached = not svc.file_memory.needs_update(rel_path)
-        file_map = svc.file_memory.get_or_build_map(rel_path)
-        resp = f"[read:{file_path}] symbols not found: {symbols}. Showing file map:\n{file_map}"
+        map_cached = _map_cached()
+        file_map = _file_map()
+        resp = (banner
+                + f"[read:{file_path}] symbols not found: {symbols}. "
+                  f"Showing file map:\n{file_map}")
         map_tok = count_tokens(file_map)
         return finalize_with_tokens(
             finalize, svc, "c3_read", {"file": file_path, "symbols": symbols},
             resp, f"{full_file_tokens()}->{map_tok}tok",
             raw_tokens=full_file_tokens(), optimized_tokens=map_tok,
             detail=map_detail(svc, rel_path, "read", cache_hit=map_cached,
-                              symbols=len(symbols), fallback="symbols_not_found"))
+                              symbols=len(symbols), fallback="symbols_not_found",
+                              record=_ext_record(), external=external))
 
     if not ranges:
-        map_cached = not svc.file_memory.needs_update(rel_path)
-        file_map = svc.file_memory.get_or_build_map(
-            rel_path, max_tokens=svc.file_memory.MAP_TOKEN_BUDGET)
+        map_cached = _map_cached()
+        file_map = _file_map(max_tokens=svc.file_memory.MAP_TOKEN_BUDGET)
         if count_tokens(file_map) >= full_file_tokens():
             # A map that costs more than the file is worth nothing: serve the
             # file (docs/file-map.md § Small files).
             file_map = (f"[read:{file_path}] whole file — smaller than its map\n"
                         + raw_text)
-        resp = (file_map
+        resp = (banner + file_map
                 + "\n[map only — pass lines=[start,end] or symbols=[...] for exact source]"
-                + maybe_related_facts(svc, rel_path, top_k=3, context="read"))
+                + _facts())
         map_tok = count_tokens(resp)
         if finalize is None:
             return resp
@@ -350,7 +412,8 @@ def handle_read(file_path: str, symbols: Any = None, lines: Any = None,
             raw_tokens=full_file_tokens(), optimized_tokens=map_tok,
             response_tokens=map_tok,
             detail=map_detail(svc, rel_path, "read", cache_hit=map_cached,
-                              fallback="map_only"))
+                              fallback="map_only", record=_ext_record(),
+                              external=external))
     else:
         # Sort and merge overlapping ranges
         ranges.sort()
@@ -387,7 +450,7 @@ def handle_read(file_path: str, symbols: Any = None, lines: Any = None,
         prev_end = end
 
     final_content = "\n".join(parts)
-    resp = final_content + maybe_related_facts(svc, rel_path, top_k=3, context="read")
+    resp = banner + final_content + _facts()
     tokens = count_tokens(resp)
     summary = f"{full_file_tokens()}->{tokens}tok" if tokens < full_file_tokens() else f"{tokens}tok"
     # C0 measurement: what the read asked for and how much source it took.
@@ -398,6 +461,7 @@ def handle_read(file_path: str, symbols: Any = None, lines: Any = None,
         "ranges": len(ranges),
         "lines_served": sum(e - s_ + 1 for s_, e in ranges),
         "file_lines": len(content_lines),
+        "external": external,
     }
     return finalize_with_tokens(
         finalize, svc, "c3_read", {"file": file_path, "symbols": symbols}, resp, summary,

{code_context_control-2.128.1 → code_context_control-2.129.0}/code_context_control.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.128.1
+Version: 2.129.0
 Summary: Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.128.1 → code_context_control-2.129.0}/code_context_control.egg-info/SOURCES.txt

@@ -460,6 +460,7 @@ tests/test_project_manager_merge.py
 tests/test_project_tool.py
 tests/test_read_coercion.py
 tests/test_read_edit_parity.py
+tests/test_read_outside_root.py
 tests/test_related_facts.py
 tests/test_repo_map.py
 tests/test_repo_shape.py

{code_context_control-2.128.1 → code_context_control-2.129.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.128.1"
+version = "2.129.0"
 description = "Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub."
 readme = "README.md"
 requires-python = ">=3.10"

{code_context_control-2.128.1 → code_context_control-2.129.0}/services/ci_act.py

@@ -116,6 +116,19 @@ def availability() -> dict:
     info["docker"] = True
     info["docker_version"] = out.strip().splitlines()[-1] if out.strip() else ""
     info["ok"] = True
+
+    # Is the default runner image already local? Absent, the first act run
+    # pulls ~1 GB, which is worth warning about but is not unreadiness. This
+    # probe deliberately does NOT pull: it cannot, in any case, predict the
+    # failure in issue #173 — there the image is present and `docker pull`
+    # succeeds, while act's own pull fails because act sends the stored
+    # registry credential and the CLI does not. Only a real act run shows
+    # that, which is why the runner classifies it (see setup_failure).
+    rc, _ = _probe(["docker", "image", "inspect", DEFAULT_IMAGE], timeout=20)
+    info["image_present"] = rc == 0
+    if rc != 0:
+        info["warning"] = (f"runner image {DEFAULT_IMAGE} is not present "
+                           "locally; the first act run pulls ~1 GB.")
     return info
 
 
@@ -243,6 +256,53 @@ def build_command(inst, project, act_path: str, event: str = "",
 _ACT_OUTPUT_LINE = re.compile(r"^\[[^\]]*\]\s{0,3}\|\s?(.*)$")
 
 
+# ── Setup-phase failures ────────────────────────────────────────────────────
+# act can fail BEFORE any workflow step runs: the runner image cannot be
+# pulled, the daemon refuses, the container never starts. Nothing the failure
+# parsers look for was ever printed, so parsing that log yields `unparsed` and
+# `c3_ci(action='failures')` answers "0 parsed failures" — for what is really
+# "the runner image could not be obtained" (issue #173). Classify it instead.
+SETUP_PARSER = "container-setup"
+
+_SETUP_FAILED = re.compile(r"(?:❌\s*)?Failure\s+-\s+Set up job", re.I)
+_DAEMON_ERROR = re.compile(r"Error response from daemon:\s*(.+)", re.I)
+_SETUP_REASONS = (
+    (re.compile(r"authentication required|incorrect username or password", re.I),
+     "the Docker registry rejected the runner image pull with an "
+     "authentication error. act sends the stored Docker credential where the "
+     "CLI sends none for a public image, so an expired token turns a public "
+     "pull into an auth failure — `docker logout` clears it."),
+    (re.compile(r"pull access denied|repository does not exist|manifest unknown", re.I),
+     "the runner image could not be found in the registry."),
+    (re.compile(r"Cannot connect to the Docker daemon|daemon is not running|"
+                r"docker daemon is not running", re.I),
+     "the Docker daemon is not reachable — start Docker and retry."),
+    (re.compile(r"no space left on device", re.I),
+     "the Docker host ran out of disk space pulling the runner image."),
+)
+
+
+def setup_failure(text: str) -> str:
+    """Why act failed before any workflow step ran, or '' if it got that far.
+
+    The verdict marker is act's own `Failure - Set up job`; the patterns after
+    it only supply a reason a human can act on. A job that reached its steps
+    and failed there is NOT a setup failure and must still go to the parsers.
+    """
+    text = text or ""
+    if not _SETUP_FAILED.search(text):
+        return ""
+    for pattern, reason in _SETUP_REASONS:
+        if pattern.search(text):
+            return f"act could not start the runner container: {reason}"
+    daemon = _DAEMON_ERROR.search(text)
+    if daemon:
+        return ("act could not start the runner container — the Docker daemon "
+                f"said: {daemon.group(1).strip()[:200]}")
+    return ("act failed during 'Set up job': the runner container never "
+            "started, so no workflow step ran.")
+
+
 def program_output(text: str) -> str:
     """Just what the commands printed, with act's prefixes removed.
 

{code_context_control-2.128.1 → code_context_control-2.129.0}/services/ci_runner.py

@@ -413,6 +413,17 @@ def _run_job_act(inst, project: Path, run_dir: Path, event: str,
         pass
 
     if result.status in (FAILED, TIMEOUT):
+        # A setup-phase failure has no program output to parse: the container
+        # never started. Parsing it anyway reported `unparsed` with a log
+        # tail, so `c3_ci(action='failures')` answered "0 parsed failures" for
+        # a broken runner (issue #173). Say what actually happened. The status
+        # stays FAILED — a job that could not run is never a green light.
+        setup_reason = ci_act.setup_failure(outcome.get("output") or "")
+        if setup_reason:
+            result.reason = setup_reason
+            result.parser = ci_act.SETUP_PARSER
+            result.failures = []
+            return result
         # Parse what the commands printed, not act's narration around it —
         # otherwise every file path arrives wearing a `[CI/lint] |` prefix.
         parsed = ci_failures.parse(

{code_context_control-2.128.1 → code_context_control-2.129.0}/services/dir_map.py

@@ -87,12 +87,44 @@ def _line_count(path: Path) -> int:
         return 0
 
 
-def render_directory_map(svc, rel_dir: str, *, max_tokens: int = DEFAULT_MAX_TOKENS) -> tuple:
-    """Return (text, detail) for the directory `rel_dir` (project-relative, posix)."""
-    root = Path(svc.project_path).resolve()
-    rel_dir = str(rel_dir).replace("\\", "/").strip("/")
-    target = (root / rel_dir).resolve() if rel_dir else root
-    label = (rel_dir + "/") if rel_dir else "./"
+def render_directory_map(svc, rel_dir: str, *, max_tokens: int = DEFAULT_MAX_TOKENS,
+                         external: bool = False) -> tuple:
+    """Return (text, detail) for the directory `rel_dir` (project-relative, posix).
+
+    `external=True` maps a directory OUTSIDE the project root: `rel_dir` is an
+    absolute path and names are relative to it. Symbols are still extracted,
+    under the same file/deadline/byte bounds — but through transient records
+    that are never persisted or looked up, because an outside file has no
+    project-relative key and indexing it would poison a store the rest of C3
+    addresses by that key. The edit ledger, which supplies the recency
+    ranking, likewise has nothing to say about a file outside the project.
+    """
+    store = getattr(svc, "file_memory", None)
+    if external:
+        root = Path(rel_dir).resolve()
+        target = root
+        name_base = ""
+        label = root.as_posix().rstrip("/") + "/"
+        recent = {}
+
+        def _cached(rel):
+            return None  # nothing outside the root is ever in the store
+
+        def _extract(rel):
+            return store.build_transient_record(root / rel, key=rel)
+    else:
+        root = Path(svc.project_path).resolve()
+        rel_dir = str(rel_dir).replace("\\", "/").strip("/")
+        target = (root / rel_dir).resolve() if rel_dir else root
+        name_base = rel_dir
+        label = (rel_dir + "/") if rel_dir else "./"
+        recent = _recent_edit_ranks(svc)
+
+        def _cached(rel):
+            return store.get(rel)
+
+        def _extract(rel):
+            return store.update(rel)
 
     files = []
     capped = False
@@ -104,9 +136,6 @@ def render_directory_map(svc, rel_dir: str, *, max_tokens: int = DEFAULT_MAX_TOK
             files.append(fp.resolve().relative_to(root).as_posix())
         except ValueError:
             continue
-
-    store = getattr(svc, "file_memory", None)
-    recent = _recent_edit_ranks(svc)
     started = time.monotonic()
     extracted = 0
     rows = []
@@ -115,7 +144,7 @@ def render_directory_map(svc, rel_dir: str, *, max_tokens: int = DEFAULT_MAX_TOK
         record = None
         if store is not None:
             try:
-                record = store.get(rel)
+                record = _cached(rel)
             except Exception:
                 record = None
             ext = Path(rel).suffix.lower()
@@ -124,7 +153,7 @@ def render_directory_map(svc, rel_dir: str, *, max_tokens: int = DEFAULT_MAX_TOK
                     and time.monotonic() - started < EXTRACT_DEADLINE_S):
                 try:
                     if (root / rel).stat().st_size <= MAX_EXTRACT_BYTES:
-                        record = store.update(rel)
+                        record = _extract(rel)
                         extracted += 1
                 except Exception:
                     record = None
@@ -135,7 +164,7 @@ def render_directory_map(svc, rel_dir: str, *, max_tokens: int = DEFAULT_MAX_TOK
         symbols = _top_symbols(record)
         rows.append({
             "rel": rel,
-            "name": rel[len(rel_dir) + 1:] if rel_dir and rel.startswith(rel_dir + "/") else rel,
+            "name": rel[len(name_base) + 1:] if name_base and rel.startswith(name_base + "/") else rel,
             "lines": lines,
             "lang": lang,
             "symbols": symbols,
@@ -172,5 +201,6 @@ def render_directory_map(svc, rel_dir: str, *, max_tokens: int = DEFAULT_MAX_TOK
         "listed": len(kept),
         "extracted": extracted,
         "capped": capped,
+        "external": bool(external),
     }
     return text, detail