@arbiterforge/ca-pi 0.15.12 → 0.16.1

package/plugins/ca-pi/hooks/_readinjectlib.py

@@ -123,6 +123,8 @@ import json
 import math
 import os
 import re
+import tempfile
+import time
 import unicodedata
 
 import _provenancelib
@@ -791,11 +793,23 @@ def governing_docs(rel, index, runner=None):
         # paths.  This is git-free.  A non-provenance Read exits here with zero
         # git calls.
         entry_paths = set()
+        v2_docs = []
         if isinstance(provenance, dict):
-            for record in provenance.values():
+            for doc_name, record in provenance.items():
                 try:
                     if not isinstance(record, dict):
                         continue
+                    if record.get("schema") == _provenancelib.V2_SCHEMA_VERSION:
+                        if not _provenancelib.valid_provenance_record(record):
+                            continue
+                        cited = any(
+                            evidence.get("kind") == "content" and evidence.get("path") == rel
+                            for field in record["fields"] for claim in field["claims"]
+                            for evidence in claim["evidence"]
+                        )
+                        if cited or record["document"]["path"] == rel:
+                            v2_docs.append(doc_name)
+                        continue
                     entries = record.get("entries")
                     if not isinstance(entries, list):
                         continue
@@ -810,6 +824,13 @@ def governing_docs(rel, index, runner=None):
                 except Exception:  # noqa: BLE001
                     continue
 
+        # A v2 content dependency is relevant advisory context, but its raw
+        # digest and semantic review cannot be proved by the legacy Git-hash
+        # gate. Point to the action-boundary audit without claiming freshness.
+        for doc_name in v2_docs:
+            result.append({"text": "{}.md context identity and semantic review unverified here -- run context-check".format(
+                _strip_context_controls(doc_name)), "tier": "standards"})
+
         # Step B: only call batch_hash when rel is a known provenance entry path.
         # Absence from entry_paths → SKIP; zero git calls.
         if rel and rel in entry_paths:
@@ -1166,6 +1187,104 @@ def spec_pointers(rel, index):
 
 _artifact_legacy_compute_injection = compute_injection
 
+def _session_context_generation_path(root, session_id):
+    # One bounded value per session avoids a shared unbounded session map and
+    # lets unrelated sessions advance without a read/modify/write race.
+    return marker_path(root, session_id, 'compaction-generation',
+                       prefix='readinject-context-')
+
+
+def _linklike(path):
+    return os.path.islink(path) or getattr(os.path, 'isjunction', lambda _: False)(path)
+
+
+def _safe_context_generation_path(root, session_id):
+    if not isinstance(root, (str, os.PathLike)) or not os.path.isabs(root):
+        return None
+    path = _session_context_generation_path(root, session_id)
+    parent = os.path.dirname(path)
+    if (_linklike(root) or _linklike(os.path.join(root, '.codearbiter')) or _linklike(parent)
+            or _linklike(path) or _linklike(path + '.lock')):
+        return None
+    return path
+
+
+def read_context_generation(root, session_id):
+    """Read a bounded worktree-local epoch; None means corrupt/unsafe/unknown."""
+    try:
+        path = _safe_context_generation_path(root, session_id)
+        if path is None:
+            return None
+        with open(path, 'rb') as stream:
+            raw = stream.read(257)
+        if len(raw) > 256 or not raw or not raw.isdigit():
+            return None
+        value = int(raw)
+        return value if value <= 1_000_000_000 else None
+    except FileNotFoundError:
+        return 0
+    except Exception:  # noqa: BLE001 - advisory hook never blocks a read
+        return None
+
+
+def bump_context_generation(root, session_id):
+    """Invalidate surviving read markers after compaction, without a scan."""
+    if not session_id:
+        return False
+    lock = None
+    lock_acquired = False
+    temporary = None
+    try:
+        path = _safe_context_generation_path(root, session_id)
+        if path is None:
+            return False
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        if _safe_context_generation_path(root, session_id) != path:
+            return False
+        lock = path + '.lock'
+        for _ in range(25):
+            try:
+                os.mkdir(lock)
+                lock_acquired = True
+                break
+            except FileExistsError:
+                time.sleep(0.01)
+        else:
+            return False
+        current = read_context_generation(root, session_id)
+        if current is None or current >= 1_000_000_000:
+            return False  # Corrupt bytes stay intact and force redelivery.
+        fd, temporary = tempfile.mkstemp(prefix='readinject-context-',
+                                          dir=os.path.dirname(path))
+        with os.fdopen(fd, 'wb') as stream:
+            stream.write(str(current + 1).encode('ascii'))
+        if _safe_context_generation_path(root, session_id) != path:
+            return False
+        os.replace(temporary, path)
+        temporary = None
+        return True
+    except Exception:  # noqa: BLE001 - task-time delivery remains the primary route
+        return False
+    finally:
+        if temporary is not None:
+            try:
+                os.unlink(temporary)
+            except OSError:
+                pass
+        if lock_acquired:
+            try:
+                os.rmdir(lock)
+            except OSError:
+                pass
+
+
+def _context_epoch_session(root, session_id):
+    generation = read_context_generation(root, session_id)
+    if generation is None:
+        return None
+    return (str(session_id) + '|context:' + str(generation)
+            if generation else session_id)
+
 
 def compute_injection(root, session_id, rel, runner=None):
     # Bind the injected pointers and dedup epoch to ONE validated HTML snapshot.
@@ -1173,8 +1292,19 @@ def compute_injection(root, session_id, rel, runner=None):
     # under B's marker, suppressing a later stable B read. HTML therefore builds
     # once before dedup; the same entries drive both context and epoch. This is
     # advisory identity only, never approval or execution authority.
+    # Preserve the legacy self-read zero-I/O path before any epoch lookup.
     if not isinstance(rel, str) or rel.replace("\\", "/").split("/", 1)[0] == ".codearbiter":
         return _artifact_legacy_compute_injection(root, session_id, rel, runner)
+    session_id = _context_epoch_session(root, session_id)
+    if session_id is None:
+        # Unknown/corrupt epoch: bounded advisory redelivery without writing
+        # a fresh marker for every read. The actor delivery planner owns its
+        # separate two-attempt accounting and action gap.
+        try:
+            index = build_index(root)
+            return assemble_context(governing_docs(rel, index, runner), budget=150)
+        except Exception:  # noqa: BLE001
+            return ""
     try:
         from _artifactlib import has_html
         if not has_html(root):

package/plugins/ca-pi/hooks/artifact-authority.py

@@ -11,6 +11,7 @@ import sys
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 import _artifactauthoritylib  # noqa: E402
 import _artifactlib  # noqa: E402
+import _artifactpromptlib  # noqa: E402
 import hostapi  # noqa: E402
 
 
@@ -54,6 +55,15 @@ def main(argv=None) -> int:
         "--codex-review-profile", choices=("native-v1",), default=None,
         help="select only after qualifying the actual registered native V1 UUID interface",
     )
+    context_arm = sub.add_parser("arm-context")
+    context_arm.add_argument("--root", required=True)
+    context_arm.add_argument("--request-file", required=True)
+    context_cancel = sub.add_parser("cancel-context")
+    context_cancel.add_argument("--root", required=True)
+    context_cancel.add_argument("--document-id", required=True)
+    context_apply = sub.add_parser("apply-context")
+    context_apply.add_argument("--root", required=True)
+    context_apply.add_argument("--receipt", required=True)
     verify = sub.add_parser("verify")
     verify.add_argument("--root", required=True)
     verify.add_argument("--request-id", required=True)
@@ -66,6 +76,9 @@ def main(argv=None) -> int:
     recover.add_argument("--disposition", required=True, choices=("failed", "abandoned"))
     args = parser.parse_args(argv)
     root = Path(args.root).resolve(strict=True)
+    if args.command == "cancel-context":
+        print(json.dumps(_artifactauthoritylib.cancel_context_preview(root, args.document_id), sort_keys=True))
+        return 0
     client = _artifactlib.ArtifactClient(
         root, _artifactlib.helper_installation(__file__)
     )
@@ -96,6 +109,11 @@ def main(argv=None) -> int:
             result["verify_command"] = (
                 f'python "{script}" verify --root "{root}" --request-id {result["request_id"]}'
             )
+    elif args.command == "arm-context":
+        preview = _artifactlib.read_context_preview_request(root, args.request_file)
+        result = _artifactauthoritylib.arm_context_preview(root, client, preview)
+    elif args.command == "apply-context":
+        result = client.call("context-apply", {"receipt": args.receipt})
     elif args.command == "verify":
         result = _artifactauthoritylib.run_verification(
             root, client, args.request_id,
@@ -113,6 +131,7 @@ def main(argv=None) -> int:
 if __name__ == "__main__":
     try:
         raise SystemExit(main())
-    except (_artifactauthoritylib.AuthorityError, _artifactlib.ArtifactError) as exc:
+    except (_artifactauthoritylib.AuthorityError, _artifactlib.ArtifactError,
+            _artifactpromptlib.PromptRouteError) as exc:
         sys.stderr.write(str(exc) + "\n")
         raise SystemExit(1)

package/plugins/ca-pi/hooks/debug-handoff.py

@@ -0,0 +1,85 @@
+# codeArbiter — private bounded debug handoff validation entry.
+# Read only stdin and the installed validator; emit closed, redacted diagnostics.
+# Bytecode suppression precedes the local import and no project state is touched.
+#
+# main(argv) -> int: validate one bounded packet and write one result envelope.
+import sys
+
+sys.dont_write_bytecode = True
+
+import json
+import re
+
+import _debughandofflib as handoff
+
+
+PROTOCOL = "codearbiter.debug-validation/1.0.0"
+DIRECT_CODES = frozenset({
+    "INPUT_LIMIT", "DEPTH_LIMIT", "INVALID_UTF8", "INVALID_JSON",
+    "DUPLICATE_KEY", "UNSUPPORTED_PROTOCOL", "REQUIRED_FIELD",
+    "UNKNOWN_FIELD", "TYPE", "VALUE",
+})
+REFERENCE_CODES = frozenset({"DUPLICATE_ID", "DANGLING_REFERENCE"})
+PATH = re.compile(r"\$(?:\.[A-Za-z_]+|\[[0-9]+\])*\Z", re.ASCII)
+
+
+def _result(valid, errors, truncated=False):
+    return {"protocol": PROTOCOL, "valid": valid,
+            "errors": errors, "truncated": truncated}
+
+
+def _diagnostic(code, path="$"):
+    if code in DIRECT_CODES or code in ("USAGE", "INPUT_IO", "INTERNAL"):
+        public_code = code
+    elif code in REFERENCE_CODES:
+        public_code = "REFERENCE"
+    else:
+        public_code = "SEMANTIC"
+    if type(path) is not str or len(path) > 256 or not PATH.fullmatch(path):
+        return {"code": "INTERNAL", "path": "$"}
+    return {"code": public_code, "path": path}
+
+
+def _write(result):
+    raw = (json.dumps(result, ensure_ascii=True, separators=(",", ":"))
+           + "\n").encode("utf-8")
+    if len(raw) > 8192:
+        result = _result(False, [{"code": "INTERNAL", "path": "$"}])
+        raw = (json.dumps(result, separators=(",", ":")) + "\n").encode("utf-8")
+        exit_code = 3
+    else:
+        exit_code = 0 if result["valid"] else 2
+        if result["errors"] and result["errors"][0]["code"] in ("INPUT_IO", "INTERNAL"):
+            exit_code = 3
+    try:
+        sys.stdout.buffer.write(raw)
+        sys.stdout.buffer.flush()
+    except OSError:
+        return 3
+    return exit_code
+
+
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv[1:]
+    if argv != ["validate"]:
+        return _write(_result(False, [_diagnostic("USAGE")]))
+    try:
+        raw = sys.stdin.buffer.read(65537)
+    except OSError:
+        return _write(_result(False, [_diagnostic("INPUT_IO")]))
+    except Exception:
+        return _write(_result(False, [_diagnostic("INTERNAL")]))
+    try:
+        packet, error = handoff.decode_packet(raw)
+        if error is not None:
+            return _write(_result(False, [_diagnostic(error)]))
+        found, truncated = handoff.validate_semantics_bounded(packet, ceiling=16)
+        errors = [_diagnostic(code, path) for code, path in found]
+        return _write(_result(not found, errors, truncated))
+    except Exception:
+        return _write(_result(False, [_diagnostic("INTERNAL")]))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/plugins/ca-pi/hooks/doctor.py

@@ -23,7 +23,9 @@ from _gitexec import git_executable, root_bound_git_env  # noqa: E402
 import hostapi  # noqa: E402 — host seam (ADR-0011): plugin-root resolution
 import _entrylib  # noqa: E402 — shared run() dispatch (jscpd dedup)
 import _githooks  # noqa: E402 — #556: git-hook drop-in registry freshness
-from _hooklib import frontmatter_enabled, get_host, set_host, utf8_stdio  # noqa: E402
+from _hooklib import (  # noqa: E402
+    frontmatter_enabled, get_host, initialized_body_text, set_host, utf8_stdio,
+)
 
 HOOK_SCRIPTS = ("session-start.py", "pre-bash.py", "pre-write.py",
                 "pre-edit.py", "post-write-edit.py", "prune-transcript.py",
@@ -298,7 +300,7 @@ def check_repo():
     if enabled:
         with open(ctx, encoding="utf-8", errors="replace") as f:
             body = f.read()
-        if "<!--INITIALIZED-->" in body:
+        if initialized_body_text(body):
             ok("project is initialized (<!--INITIALIZED--> marker present)")
         else:
             warn(f"no <!--INITIALIZED--> marker — startup will route to "

package/plugins/ca-pi/hooks/hostapi.py

@@ -313,7 +313,7 @@ class Host:
 
     name = "claude"
     adapter_name = "ca"
-    adapter_version = "2.23.4"
+    adapter_version = "2.24.1"
 
     # Update-notifier descriptor. Each independently versioned host overrides
     # these three values in its per-plugin _host.py. Keeping the target,

package/plugins/ca-pi/hooks/init-codearbiter.py

@@ -12,11 +12,16 @@
 # Usage:
 #   python init-codearbiter.py [--root PATH] [--stage N]
 #   python init-codearbiter.py --check        # report state, create nothing
+#   python init-codearbiter.py --check --passive --root PATH  # external pre-session read
 #   python init-codearbiter.py --repair-lock-exclusion [--root PATH]
+#   python init-codearbiter.py --root PATH --context-request FILE  # bounded writer bridge, including initialized refresh
 
 import argparse
+import json
 import subprocess
 import os
+import re
+import stat
 import sys
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
@@ -25,6 +30,8 @@ from _taskboardlib import DONE_TASKS  # noqa: E402 — shared archive template (
 import hostapi  # noqa: E402 — host seam (ADR-0011)
 import _hooklib  # noqa: E402 — set_host DI seam (#257)
 import _entrylib  # noqa: E402 — shared run() dispatch (jscpd dedup)
+from _activationlib import passive_activation_inventory  # noqa: E402
+import _artifactlib  # noqa: E402
 
 # NOTE: this stub deliberately does NOT contain the initialization sentinel
 # (an HTML comment wrapping the word INITIALIZED). The SessionStart hook greps
@@ -122,17 +129,132 @@ def project_root(opt):
     return os.path.abspath(os.getcwd())
 
 
+def _regular_scaffold_entry(path, *, directory):
+    """Reject aliases and reparse points before reading or creating scaffold state."""
+    try:
+        info = os.lstat(path)
+    except OSError:
+        return False
+    reparse = getattr(info, "st_file_attributes", 0) & getattr(
+        stat, "FILE_ATTRIBUTE_REPARSE_POINT", 0)
+    return not reparse and (stat.S_ISDIR(info.st_mode) if directory
+                            else stat.S_ISREG(info.st_mode))
+
+
+def _scaffold_inventory(cad, ctx, requested_stage):
+    """Return absent scaffold names only when surviving state is safe to retain."""
+    names = ("CONTEXT.md", *FILES)
+    if os.path.lexists(cad) and not _regular_scaffold_entry(cad, directory=True):
+        raise SystemExit(f"REFUSING: {cad} is not a regular project-state directory.")
+    present = {name for name in names if os.path.lexists(os.path.join(cad, name))}
+    if not present:
+        if os.path.isdir(cad) and os.listdir(cad):
+            raise SystemExit(f"REFUSING: {cad} has existing state without a scaffold; inspect it first.")
+        return list(names), False
+    for name in present:
+        path = os.path.join(cad, name)
+        if not _regular_scaffold_entry(path, directory=False):
+            raise SystemExit(f"REFUSING: {path} is not a regular scaffold file.")
+    if "CONTEXT.md" not in present:
+        # A missing stub amid content/provenance may be an interrupted native
+        # transaction. Only the known scaffold prefix can be resumed here.
+        unexpected = set(os.listdir(cad)) - set(FILES)
+        if unexpected:
+            raise SystemExit(f"REFUSING: {ctx} is absent amid other project state; inspect prior write outcome.")
+    else:
+        try:
+            with open(ctx, encoding="utf-8") as handle:
+                body = handle.read()
+        except (OSError, UnicodeError) as exc:
+            raise SystemExit(f"REFUSING: cannot inspect {ctx}: {exc}") from None
+        enabled, malformed = _hooklib.frontmatter_enabled_text(body)
+        lines = body.splitlines()
+        boundary = next((index for index, line in enumerate(lines[1:], 1)
+                         if line.strip() == "---"), None)
+        stages = ([match.group(1) for line in lines[1:boundary]
+                   if (match := re.fullmatch(r"\s*stage:\s*([1-9][0-9]*)\s*", line))]
+                  if boundary is not None else [])
+        if (not enabled or malformed or len(stages) != 1 or
+                _hooklib.initialized_body_text(body)):
+            raise SystemExit(f"REFUSING: {ctx} is invalid or initialized; inspect before recovery.")
+        if requested_stage is not None and int(stages[0]) != requested_stage:
+            raise SystemExit(f"REFUSING: {ctx} stage differs from --stage; preserve existing context.")
+    headers = {"open-tasks.md": "# Open tasks", "done-tasks.md": "# Done tasks",
+               "open-questions.md": "# Open questions",
+               "overrides.log": "# codeArbiter override log"}
+    for name in present & headers.keys():
+        path = os.path.join(cad, name)
+        try:
+            with open(path, encoding="utf-8") as handle:
+                valid = handle.readline().rstrip("\r\n").startswith(headers[name])
+        except (OSError, UnicodeError):
+            valid = False
+        if not valid:
+            raise SystemExit(f"REFUSING: {path} has an unrecognized header; preserve it for review.")
+    if "last-checkpoint" in present:
+        try:
+            with open(os.path.join(cad, "last-checkpoint"), encoding="utf-8") as handle:
+                valid = bool(re.fullmatch(r"[0-9]+\s*", handle.read()))
+        except (OSError, UnicodeError):
+            valid = False
+        if not valid:
+            raise SystemExit("REFUSING: last-checkpoint is malformed; preserve it for review.")
+    return [name for name in names if name not in present], True
+
+
+def _create_scaffold_file(path, content, *, newline=None):
+    """Create once; a concurrent new file is a conflict, never an overwrite."""
+    flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL
+    flags |= getattr(os, "O_NOFOLLOW", 0)
+    try:
+        fd = os.open(path, flags, 0o666)
+    except FileExistsError:
+        raise SystemExit(f"REFUSING: {path} appeared during scaffold recovery.") from None
+    with os.fdopen(fd, "w", encoding="utf-8", newline=newline) as handle:
+        handle.write(content)
+
+
 def main(argv=None):
     ap = argparse.ArgumentParser(add_help=True)
     ap.add_argument("--root")
     ap.add_argument("--stage", type=int)
     ap.add_argument("--check", action="store_true")
+    ap.add_argument("--passive", action="store_true", help=(
+        "inspect explicit root before host activation; no Git or network probes"))
+    ap.add_argument("--context-request", help=argparse.SUPPRESS)
     ap.add_argument("--repair-lock-exclusion", action="store_true", help=(
         "repair only Git-local info/exclude for an existing scaffold; retain the "
         "task-board OS lock, never rewrite project state (cannot combine with --check/--stage)"))
     args = ap.parse_args(argv)
+    if args.context_request:
+        if not args.root or args.stage is not None or args.check or args.passive or args.repair_lock_exclusion:
+            ap.error("--context-request requires --root and excludes scaffold flags")
+        try:
+            root = _artifactlib._trusted_directory(args.root, "UNSAFE_ROOT")
+            request = _artifactlib.read_context_preview_request(root, args.context_request)
+            operation, payload = _artifactlib.validate_context_writer_request(request)
+            client = _artifactlib.context_writer_client(root)
+            if operation == "preview":
+                from _artifactauthoritylib import arm_context_preview
+                result = arm_context_preview(root, client, payload)
+            else:
+                result = client.call("context-apply", payload)
+        except RuntimeError as exc:
+            raise SystemExit(f"REFUSING context request: {exc}") from None
+        print(json.dumps(result, sort_keys=True))
+        return
+    if args.passive:
+        if not args.check or not args.root or args.stage is not None or args.repair_lock_exclusion:
+            ap.error("--passive requires --check and --root; excludes --stage and repair")
+        try:
+            report = passive_activation_inventory(args.root)
+        except (OSError, UnicodeError, ValueError) as exc:
+            raise SystemExit(f"REFUSING passive inspection: {exc}") from None
+        print(json.dumps(report, sort_keys=True))
+        return
     if args.repair_lock_exclusion and (args.check or args.stage is not None):
         ap.error("--repair-lock-exclusion cannot combine with --check or --stage")
+    requested_stage = args.stage
     if args.stage is None:
         args.stage = 1
 
@@ -149,13 +271,17 @@ def main(argv=None):
     name = os.path.basename(root.rstrip("/\\")) or "project"
 
     if args.check:
+        if os.path.lexists(cad) and not _regular_scaffold_entry(cad, directory=True):
+            raise SystemExit(f"REFUSING: {cad} is not a regular project-state directory.")
+        if os.path.lexists(ctx) and not _regular_scaffold_entry(ctx, directory=False):
+            raise SystemExit(f"REFUSING: {ctx} is not a regular scaffold file.")
         if os.path.exists(ctx):
             print(f"ALREADY SCAFFOLDED: {ctx} exists.")
             with open(ctx, encoding="utf-8", errors="replace") as f:
                 text = f.read()
-            import re
-            initd = bool(re.search(r"(?m)^\s*<!--\s*INITIALIZED\s*-->\s*$", text))
-            print("arbiter: " + ("enabled" if re.search(r"(?m)^arbiter:\s*enabled\s*$", text) else "not enabled"))
+            initd = _hooklib.initialized_body_text(text)
+            enabled, _malformed = _hooklib.frontmatter_enabled_text(text)
+            print("arbiter: " + ("enabled" if enabled else "not enabled"))
             print("initialized body: " + ("yes" if initd else
                   "no (run " + _cc + " or " + _dc + ")"))
         else:
@@ -164,7 +290,8 @@ def main(argv=None):
 
     from _taskexcludelib import ensure_task_lock_excluded, TaskExclusionError
     if args.repair_lock_exclusion:
-        if not os.path.isfile(ctx) or os.path.islink(ctx):
+        if (not _regular_scaffold_entry(cad, directory=True) or
+                not _regular_scaffold_entry(ctx, directory=False)):
             raise SystemExit("REFUSING: task lock exclusion repair requires an existing scaffold.")
         try:
             result = ensure_task_lock_excluded(root, required=True)
@@ -173,7 +300,8 @@ def main(argv=None):
         print(f"task lock exclusion: {result}")
         return
 
-    if os.path.exists(ctx):
+    absent, recovering = _scaffold_inventory(cad, ctx, requested_stage)
+    if recovering and not absent:
         raise SystemExit(
             f"REFUSING: {ctx} already exists. .codearbiter/ is already scaffolded here. "
             f"To populate it, run {_cc} or {_dc}; to repair, edit by hand.")
@@ -187,19 +315,16 @@ def main(argv=None):
 
     os.makedirs(cad, exist_ok=True)
     created = []
-    if not os.path.exists(ctx):
-        with open(ctx, "w", encoding="utf-8") as f:
-            f.write(CONTEXT.format(stage=args.stage, name=name,
-                                   create_context=_cc, decompose=_dc))
+    if "CONTEXT.md" in absent:
+        _create_scaffold_file(ctx, CONTEXT.format(stage=args.stage, name=name,
+                              create_context=_cc, decompose=_dc))
         created.append("CONTEXT.md")
     for fname, content in FILES.items():
-        fp = os.path.join(cad, fname)
-        if not os.path.exists(fp):
+        if fname in absent:
             # Match taskwrite's LF output for this shared append-only template
             # on Windows too; other scaffold files retain their existing EOLs.
             newline = "\n" if fname == "done-tasks.md" else None
-            with open(fp, "w", encoding="utf-8", newline=newline) as f:
-                f.write(content)
+            _create_scaffold_file(os.path.join(cad, fname), content, newline=newline)
             created.append(fname)
 
     # #161: install the git-level enforcement backstop (pre-commit/pre-push) so
@@ -215,9 +340,12 @@ def main(argv=None):
     except Exception as e:  # noqa: BLE001
         print(f"git hooks: install skipped ({e})", file=sys.stderr)
 
-    print(f"SCAFFOLDED .codearbiter/ at {cad}")
+    print(f"{'RECOVERED' if recovering else 'SCAFFOLDED'} .codearbiter/ at {cad}")
     print("created: " + ", ".join(created))
-    print(f"arbiter: enabled (stage {args.stage}); CONTEXT.md is a stub (no <!--INITIALIZED--> sentinel).")
+    if recovering and "CONTEXT.md" not in created:
+        print("arbiter: enabled; existing uninitialized CONTEXT.md and history retained.")
+    else:
+        print(f"arbiter: enabled (stage {args.stage}); CONTEXT.md is a stub (no <!--INITIALIZED--> sentinel).")
     print(f"Next: run {_cc} (source exists) or {_dc} (greenfield) to populate.")
 
 

package/plugins/ca-pi/hooks/prompt-submit.py

@@ -65,6 +65,7 @@ import sys
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 import hostapi  # noqa: E402 — host seam (ADR-0011)
 import _approvallib  # noqa: E402 — host-owned artifact approval capture
+import _artifactauthoritylib  # noqa: E402 — exact context preview approval capture
 import _hooklib  # noqa: E402
 import _modelib  # noqa: E402 — mode plane core (T-06..T-16, Lane A)
 import _prerequisitelib  # noqa: E402 — host-owned prerequisite capture
@@ -485,6 +486,15 @@ def _handle_user_prompt_submit(payload, host):
         )
         if reconciliation:
             contexts.append(reconciliation)
+        context_preview = _artifactauthoritylib.capture_context_preview_from_hook(
+            root=root,
+            plugin_root=host.plugin_root(),
+            prompt=prompt,
+            host=host.name,
+            session_id=session_id,
+        )
+        if context_preview:
+            contexts.append(context_preview)
         approval_context = "\n".join(contexts)
     if not active:
         if not approval_context:
@@ -513,6 +523,10 @@ def _handle_precompact(payload, host):
     if not _hooklib.arbiter_active(root):
         return 0
     _bump_compaction_generation(_hooklib.marker_root(payload), session_id)
+    # Read-time context pointers have their own worktree-local epoch. A
+    # surviving read marker cannot prove that a compacted actor still carries
+    # those pointers. Keep this separate from the persona generation above.
+    _readinjectlib.bump_context_generation(root, session_id)
     return 0