@memorax/memorax-code 0.1.2 → 0.1.4

package/lib/memorax-code-codex-adapter/skills/memorax-code/scripts/collect_all.py

@@ -13,6 +13,15 @@ from typing import Any, Optional
 SCRIPT_DIR = Path(__file__).resolve().parent
 DEFAULTS_PATH = SCRIPT_DIR.parent / "defaults.json"
 FALLBACK_DEFAULTS = {
+    "repoHistory": {
+        "mode": "provider",
+        "limits": {
+            "commits": 30,
+            "prs": 30,
+            "issues": 30,
+        },
+    },
+    # Kept for compatibility with defaults.json v1.
     "limits": {
         "commits": 30,
         "prs": 30,
@@ -21,6 +30,8 @@ FALLBACK_DEFAULTS = {
     "summaryChars": 4000,
 }
 
+HISTORY_MODES = {"none", "commits-only", "local-only", "provider", "provider-required"}
+
 
 class ProgressBar:
     def __init__(self, enabled: bool, total: int) -> None:
@@ -102,6 +113,7 @@ def write_failure(
     steps: Optional[dict[str, Any]] = None,
     outputs: Optional[dict[str, str]] = None,
     notices: Optional[list[dict[str, Any]]] = None,
+    effective_settings: Optional[dict[str, Any]] = None,
 ) -> int:
     emit_process_output(result)
     step_reports = dict(steps or {})
@@ -121,6 +133,8 @@ def write_failure(
         report["outputs"] = outputs
     if notices:
         report["notices"] = notices
+    if effective_settings is not None:
+        report["effective_settings"] = effective_settings
     write_report(report, pretty)
     return result.returncode or 1
 
@@ -234,16 +248,53 @@ def validate_range(parser: argparse.ArgumentParser, name: str, value: int, minim
         parser.error(f"{name} must be from {minimum} to {maximum}")
 
 
+def default_history_mode(settings: dict[str, Any]) -> str:
+    history = settings.get("repoHistory")
+    if not isinstance(history, dict):
+        return "provider"
+    mode = history.get("mode", "provider")
+    if not isinstance(mode, str) or mode not in HISTORY_MODES:
+        raise ValueError(f"{DEFAULTS_PATH}: repoHistory.mode must be one of {', '.join(sorted(HISTORY_MODES))}")
+    return mode
+
+
+def default_limit(settings: dict[str, Any], key: str) -> int:
+    history = settings.get("repoHistory")
+    if isinstance(history, dict) and isinstance(history.get("limits"), dict) and history["limits"].get(key) is not None:
+        return default_int(settings, ["repoHistory", "limits", key], FALLBACK_DEFAULTS["repoHistory"]["limits"][key])
+    return default_int(settings, ["limits", key], FALLBACK_DEFAULTS["limits"][key])
+
+
+def history_collect(mode: str) -> dict[str, bool]:
+    return {
+        "commits": mode != "none",
+        "provider": mode in {"provider", "provider-required"},
+    }
+
+
+def resolve_history_mode(args: argparse.Namespace, default_mode: str) -> str:
+    mode = args.history_mode or default_mode
+    if args.skip_provider:
+        mode = "local-only"
+    if args.require_provider:
+        mode = "provider-required"
+    return mode
+
+
 def apply_effective_settings(args: argparse.Namespace, parser: argparse.ArgumentParser) -> argparse.Namespace:
     try:
         defaults, source = load_default_settings()
-        default_commit_limit = default_int(defaults, ["limits", "commits"], FALLBACK_DEFAULTS["limits"]["commits"])
-        default_pr_limit = default_int(defaults, ["limits", "prs"], FALLBACK_DEFAULTS["limits"]["prs"])
-        default_issue_limit = default_int(defaults, ["limits", "issues"], FALLBACK_DEFAULTS["limits"]["issues"])
+        default_mode = default_history_mode(defaults)
+        default_commit_limit = default_limit(defaults, "commits")
+        default_pr_limit = default_limit(defaults, "prs")
+        default_issue_limit = default_limit(defaults, "issues")
         default_summary_chars = default_int(defaults, ["summaryChars"], FALLBACK_DEFAULTS["summaryChars"])
     except ValueError as exc:
         parser.error(str(exc))
 
+    history_mode = resolve_history_mode(args, default_mode)
+    collect = history_collect(history_mode)
+
     commit_limit = args.commit_limit if args.commit_limit is not None else default_commit_limit
     pr_limit = args.pr_limit if args.pr_limit is not None else default_pr_limit
     issue_limit = args.issue_limit if args.issue_limit is not None else default_issue_limit
@@ -255,7 +306,13 @@ def apply_effective_settings(args: argparse.Namespace, parser: argparse.Argument
     if summary_chars < 100:
         parser.error("--summary-chars must be at least 100")
 
-    overrides: dict[str, int] = {}
+    overrides: dict[str, Any] = {}
+    if args.history_mode is not None:
+        overrides["history_mode"] = args.history_mode
+    if args.skip_provider:
+        overrides["skip_provider"] = True
+    if args.require_provider:
+        overrides["require_provider"] = True
     if args.commit_limit is not None:
         overrides["commit_limit"] = args.commit_limit
     if args.pr_limit is not None:
@@ -269,7 +326,13 @@ def apply_effective_settings(args: argparse.Namespace, parser: argparse.Argument
     args.pr_limit = pr_limit
     args.issue_limit = issue_limit
     args.summary_chars = summary_chars
+    args.history_mode = history_mode
+    args.history_collect = collect
     args.effective_settings = {
+        "history": {
+            "mode": history_mode,
+            "collect": collect,
+        },
         "limits": {
             "commits": commit_limit,
             "prs": pr_limit,
@@ -291,6 +354,7 @@ def parse_args(argv: list[str]) -> argparse.Namespace:
     parser.add_argument("--pr-limit", type=int, default=None, help="Maximum snapshot-filtered PRs/MRs retained")
     parser.add_argument("--issue-limit", type=int, default=None, help="Maximum provider issues retained")
     parser.add_argument("--summary-chars", type=int, default=None)
+    parser.add_argument("--history-mode", choices=sorted(HISTORY_MODES), default=None, help="History evidence policy for this build")
     parser.add_argument("--skip-provider", action="store_true", help="Skip GitHub/GitLab PR/MR/issue collection and build local-only memory")
     parser.add_argument("--require-provider", action="store_true", help="Fail if provider PR/MR/issue evidence cannot be collected")
     parser.add_argument("--pretty", action="store_true", help="Pretty-print JSON")
@@ -302,6 +366,10 @@ def parse_args(argv: list[str]) -> argparse.Namespace:
     args = parser.parse_args(argv)
     if args.skip_provider and args.require_provider:
         parser.error("--skip-provider and --require-provider cannot be used together")
+    if args.history_mode and args.skip_provider and args.history_mode != "local-only":
+        parser.error(f"--skip-provider cannot be combined with --history-mode {args.history_mode}")
+    if args.history_mode and args.require_provider and args.history_mode != "provider-required":
+        parser.error("--require-provider cannot be combined with a non-required history mode")
     args.repo_path = Path(args.repo_path).expanduser().resolve()
     return apply_effective_settings(args, parser)
 
@@ -330,38 +398,50 @@ def main(argv: list[str]) -> int:
     notices = provider_notices(prepare_data)
 
     git_commits_path = raw_dir / "git-commits.json"
-    git_commits = run_step(
-        [
-            sys.executable,
-            str(SCRIPT_DIR / "git_commit_facets.py"),
-            "--repo-path",
-            str(repo),
-            "--snapshot-ref",
-            args.snapshot_ref,
-            "--limit",
-            str(args.commit_limit),
-            "--summary-chars",
-            str(args.summary_chars),
-            "--out",
-            str(git_commits_path),
-        ],
-        repo,
-    )
     outputs = {
         "prepare_report": str(prepare_report_path),
         "git_commits": str(git_commits_path),
     }
-    if git_commits.returncode != 0:
-        progress.fail(1, "git commits failed")
-        return write_failure(
-            "git_commits",
-            git_commits,
-            args.pretty,
-            repo=repo,
-            memory=memory,
-            steps={"prepare": json_step(prepare)},
-            outputs=outputs,
+    if args.history_collect["commits"]:
+        git_commits = run_step(
+            [
+                sys.executable,
+                str(SCRIPT_DIR / "git_commit_facets.py"),
+                "--repo-path",
+                str(repo),
+                "--snapshot-ref",
+                args.snapshot_ref,
+                "--limit",
+                str(args.commit_limit),
+                "--summary-chars",
+                str(args.summary_chars),
+                "--out",
+                str(git_commits_path),
+            ],
+            repo,
         )
+        git_commits_step = json_step(git_commits)
+        if git_commits.returncode != 0:
+            progress.fail(1, "git commits failed")
+            return write_failure(
+                "git_commits",
+                git_commits,
+                args.pretty,
+                repo=repo,
+                memory=memory,
+                steps={"prepare": json_step(prepare)},
+                outputs=outputs,
+            )
+    else:
+        git_commits_path.write_text("[]\n", encoding="utf-8")
+        git_commits_step = {
+            "ok": True,
+            "exit_code": 0,
+            "stdout": "",
+            "stderr": "",
+            "skipped": True,
+            "reason": "history_disabled_by_policy",
+        }
     progress.update(2, "git commits")
 
     provider = provider_report(prepare_data)
@@ -369,11 +449,12 @@ def main(argv: list[str]) -> int:
     provider_facets: dict[str, Any]
     provider_output = raw_dir / provider_raw_name(provider_name)
     provider_script_name = provider_script(provider_name)
-    if args.skip_provider:
+    if not args.history_collect["provider"]:
+        reason = "provider_skipped_by_user" if args.skip_provider else "history_disabled_by_policy" if args.history_mode == "none" else "history_provider_disabled_by_policy"
         provider_facets = {
             "ok": True,
             "skipped": True,
-            "reason": "provider_skipped_by_user",
+            "reason": reason,
             "output": "",
         }
     elif provider["evidence_state"] == "ready" and provider_script_name and provider["repo"]:
@@ -408,12 +489,12 @@ def main(argv: list[str]) -> int:
             "output": str(provider_output),
         }
         if provider_result.returncode != 0:
-            provider_facets["degraded_to_local_only"] = not args.require_provider
+            provider_facets["degraded_to_local_only"] = args.history_mode != "provider-required"
             provider_facets["reason"] = "provider_facets_failed"
             provider_facets["output"] = ""
             if provider_output.exists():
                 provider_output.unlink()
-            if args.require_provider:
+            if args.history_mode == "provider-required":
                 progress.fail(2, "provider facets failed")
                 return write_failure(
                     "provider_facets",
@@ -424,16 +505,17 @@ def main(argv: list[str]) -> int:
                     provider=provider,
                     steps={
                         "prepare": json_step(prepare),
-                        "git_commits": json_step(git_commits),
+                        "git_commits": git_commits_step,
                     },
                     outputs=outputs,
                     notices=[provider_failure_notice(provider, provider_result, continuing=False)],
+                    effective_settings=args.effective_settings,
                 )
             notices.append(provider_failure_notice(provider, provider_result, continuing=True))
         else:
             outputs["provider_facets"] = provider_facets["output"]
     else:
-        if args.require_provider:
+        if args.history_mode == "provider-required":
             provider_result = subprocess.CompletedProcess(
                 args=[],
                 returncode=1,
@@ -450,10 +532,11 @@ def main(argv: list[str]) -> int:
                 provider=provider,
                 steps={
                     "prepare": json_step(prepare),
-                    "git_commits": json_step(git_commits),
+                    "git_commits": git_commits_step,
                 },
                 outputs=outputs,
                 notices=notices,
+                effective_settings=args.effective_settings,
             )
         provider_facets = {
             "ok": True,
@@ -481,7 +564,7 @@ def main(argv: list[str]) -> int:
         "effective_settings": args.effective_settings,
         "steps": {
             "prepare": json_step(prepare),
-            "git_commits": json_step(git_commits),
+            "git_commits": git_commits_step,
             "provider_facets": provider_facets,
         },
         "outputs": outputs,

package/lib/memorax-code-codex-adapter/skills/memorax-code/scripts/detect_updates.py

@@ -27,7 +27,16 @@ BUILDER_HELPER_FILES = {
     "gitlab_resource_facets": BUILDER_SCRIPTS_DIR / "gitlab_resource_facets.py",
 }
 PREFERRED_REMOTE_NAMES = ("upstream", "origin")
+HISTORY_MODES = {"none", "commits-only", "local-only", "provider", "provider-required"}
 FALLBACK_DEFAULTS = {
+    "repoHistory": {
+        "mode": "provider",
+        "limits": {
+            "prs": 30,
+            "issues": 30,
+        },
+    },
+    # Kept for compatibility with defaults.json v1.
     "limits": {
         "prs": 30,
         "issues": 30,
@@ -69,6 +78,30 @@ def default_int(settings: dict[str, Any], path: list[str], fallback: int) -> int
     return value
 
 
+def default_limit(settings: dict[str, Any], key: str) -> int:
+    history = settings.get("repoHistory")
+    if isinstance(history, dict) and isinstance(history.get("limits"), dict) and history["limits"].get(key) is not None:
+        return default_int(settings, ["repoHistory", "limits", key], FALLBACK_DEFAULTS["repoHistory"]["limits"][key])
+    return default_int(settings, ["limits", key], FALLBACK_DEFAULTS["limits"][key])
+
+
+def default_history_mode(settings: dict[str, Any]) -> str:
+    history = settings.get("repoHistory")
+    if not isinstance(history, dict):
+        return "provider"
+    mode = history.get("mode", "provider")
+    if not isinstance(mode, str) or mode not in HISTORY_MODES:
+        raise ValueError(f"{BUILDER_DEFAULTS_PATH}: repoHistory.mode must be one of {', '.join(sorted(HISTORY_MODES))}")
+    return mode
+
+
+def history_collect(mode: str) -> dict[str, bool]:
+    return {
+        "commits": mode in {"commits-only", "local-only", "provider", "provider-required"},
+        "provider": mode in {"provider", "provider-required"},
+    }
+
+
 def load_default_settings() -> tuple[dict[str, Any], str]:
     if not BUILDER_DEFAULTS_PATH.exists():
         return FALLBACK_DEFAULTS, "hardcoded_fallback"
@@ -86,12 +119,19 @@ def validate_range(parser: argparse.ArgumentParser, name: str, value: int, minim
 def apply_effective_settings(args: argparse.Namespace, parser: argparse.ArgumentParser) -> argparse.Namespace:
     try:
         defaults, source = load_default_settings()
-        default_pr_limit = default_int(defaults, ["limits", "prs"], FALLBACK_DEFAULTS["limits"]["prs"])
-        default_issue_limit = default_int(defaults, ["limits", "issues"], FALLBACK_DEFAULTS["limits"]["issues"])
+        default_mode = default_history_mode(defaults)
+        default_pr_limit = default_limit(defaults, "prs")
+        default_issue_limit = default_limit(defaults, "issues")
         default_summary_chars = default_int(defaults, ["summaryChars"], FALLBACK_DEFAULTS["summaryChars"])
     except ValueError as exc:
         parser.error(str(exc))
 
+    history_mode = args.history_mode or default_mode
+    collect = history_collect(history_mode)
+    if args.provider_mode == "off":
+        if history_mode == "provider-required":
+            parser.error("--provider-mode off cannot be combined with --history-mode provider-required")
+        collect = {**collect, "provider": False}
     pr_limit = args.pr_limit if args.pr_limit is not None else default_pr_limit
     issue_limit = args.issue_limit if args.issue_limit is not None else default_issue_limit
     summary_chars = args.summary_chars if args.summary_chars is not None else default_summary_chars
@@ -101,7 +141,9 @@ def apply_effective_settings(args: argparse.Namespace, parser: argparse.Argument
     if summary_chars < 100:
         parser.error("--summary-chars must be at least 100")
 
-    overrides: dict[str, int] = {}
+    overrides: dict[str, Any] = {}
+    if args.history_mode is not None:
+        overrides["history_mode"] = args.history_mode
     if args.pr_limit is not None:
         overrides["pr_limit"] = args.pr_limit
     if args.issue_limit is not None:
@@ -109,10 +151,16 @@ def apply_effective_settings(args: argparse.Namespace, parser: argparse.Argument
     if args.summary_chars is not None:
         overrides["summary_chars"] = args.summary_chars
 
+    args.history_mode = history_mode
+    args.history_collect = collect
     args.pr_limit = pr_limit
     args.issue_limit = issue_limit
     args.summary_chars = summary_chars
     args.effective_settings = {
+        "history": {
+            "mode": history_mode,
+            "collect": collect,
+        },
         "limits": {
             "prs": pr_limit,
             "issues": issue_limit,
@@ -592,13 +640,13 @@ def cli_evidence_state(command: str, host: str) -> tuple[str, bool]:
     return ("ready", True) if result.returncode == 0 else ("auth_required", True)
 
 
-def provider_report(repo: Path, memory: Path) -> dict[str, Any]:
+def provider_report(repo: Path, memory: Path, *, inspect_cli: bool = True) -> dict[str, Any]:
     remote = provider_from_profile(memory) or parse_code_host_repo(git(repo, ["remote", "-v"], "git could not list remotes"))
     provider = remote["provider"]
     cli = "gh" if provider == "github" else "glab" if provider == "gitlab" else ""
-    evidence_state = "unavailable"
+    evidence_state = "unavailable" if inspect_cli else "skipped_by_policy"
     cli_available = False
-    if cli:
+    if cli and inspect_cli:
         evidence_state, cli_available = cli_evidence_state(cli, remote["host"])
     return {
         "name": provider,
@@ -766,6 +814,7 @@ def parse_args(argv: list[str]) -> argparse.Namespace:
     parser.add_argument("--repo-path", default=".", help="Local git repository path")
     parser.add_argument("--memory-path", help="Existing .repo_memory path; defaults to <repo>/.repo_memory")
     parser.add_argument("--snapshot-ref", default="HEAD", help="Local git ref used for current detection")
+    parser.add_argument("--history-mode", choices=sorted(HISTORY_MODES), default=None, help="History evidence policy for this update")
     parser.add_argument("--provider-mode", choices=["auto", "off"], default="auto", help="Whether to fetch latest provider PR/issue facets when provider evidence is ready")
     parser.add_argument("--pr-limit", type=int, default=None, help="Maximum latest PR/MR candidates to compare")
     parser.add_argument("--issue-limit", type=int, default=None, help="Maximum latest issue candidates to compare")
@@ -793,12 +842,19 @@ def main(argv: list[str]) -> int:
 
     head = git(repo, ["rev-parse", "--verify", f"{args.snapshot_ref}^{{commit}}"], f"git could not resolve {args.snapshot_ref!r}")
     baseline_sha = commit_baseline(memory, repo, head)
-    local_commits, local_commit_status = commit_delta(repo, baseline_sha, head)
+    if args.history_collect["commits"]:
+        local_commits, local_commit_status = commit_delta(repo, baseline_sha, head)
+    else:
+        local_commits, local_commit_status = [], {
+            "status": "skipped",
+            "reason": "history_disabled_by_policy",
+            "message": "Local commit delta detection is disabled by repoHistory.mode.",
+        }
 
     existing_prs = baseline_items(memory, "prs.md", "pr")
     existing_issues = baseline_items(memory, "issues.md", "issue")
-    provider = provider_report(repo, memory)
-    if args.provider_mode == "auto":
+    provider = provider_report(repo, memory, inspect_cli=args.history_collect["provider"])
+    if args.history_collect["provider"]:
         provider_fetch, current_prs, current_issues = fetch_provider_items(
             repo,
             provider,
@@ -808,7 +864,14 @@ def main(argv: list[str]) -> int:
             args.summary_chars,
         )
     else:
-        provider_fetch, current_prs, current_issues = {"attempted": False, "reason": "provider-mode=off"}, [], []
+        reason = (
+            "provider-mode=off"
+            if args.provider_mode == "off"
+            else "history_disabled_by_policy"
+            if args.history_mode == "none"
+            else "history_provider_disabled_by_policy"
+        )
+        provider_fetch, current_prs, current_issues = {"attempted": False, "reason": reason}, [], []
     fetched_prs = current_prs if provider_fetch.get("ok") is True else []
     fetched_issues = current_issues if provider_fetch.get("ok") is True else []
     if not current_prs and provider_fetch.get("ok") is not True:

package/lib/memorax-code-codex-adapter/skills/memorax-code/scripts/github_resource_facets.py

@@ -88,8 +88,16 @@ def is_git_ancestor(repo_path: Path, ancestor_sha: str, descendant_sha: str) ->
         return True
     if result.returncode == 1:
         return False
+    stderr = result.stderr.strip()
+    normalized_stderr = stderr.lower()
+    if (
+        "not a valid commit" in normalized_stderr
+        or "no such commit" in normalized_stderr
+        or "not a valid object name" in normalized_stderr
+    ):
+        return False
     raise SystemExit(
-        f"git could not compare {ancestor_sha} with snapshot {descendant_sha} in {repo_path}:\n{result.stderr.strip()}"
+        f"git could not compare {ancestor_sha} with snapshot {descendant_sha} in {repo_path}:\n{stderr}"
     )
 
 

package/lib/memorax-code-codex-adapter/skills/memorax-code/scripts/gitlab_resource_facets.py

@@ -117,8 +117,16 @@ def is_git_ancestor(repo_path: Path, ancestor_sha: str, descendant_sha: str) ->
         return True
     if result.returncode == 1:
         return False
+    stderr = result.stderr.strip()
+    normalized_stderr = stderr.lower()
+    if (
+        "not a valid commit" in normalized_stderr
+        or "no such commit" in normalized_stderr
+        or "not a valid object name" in normalized_stderr
+    ):
+        return False
     raise SystemExit(
-        f"git could not compare {ancestor_sha} with snapshot {descendant_sha} in {repo_path}:\n{result.stderr.strip()}"
+        f"git could not compare {ancestor_sha} with snapshot {descendant_sha} in {repo_path}:\n{stderr}"
     )
 
 

package/lib/memorax-code-codex-adapter/skills/memorax-code/scripts/validate_memory.py

@@ -19,6 +19,7 @@ BASELINE_FILES = [
 
 PROVIDER_RAW_FILES = [Path("raw/github-facets.json"), Path("raw/gitlab-facets.json")]
 PROVIDER_RESOURCE_FILES = [Path("resources/prs.md"), Path("resources/issues.md")]
+DISABLED_RESOURCE_SOURCES = {"history_disabled", "provider_skipped_local_only", "provider_unavailable", "github_resource_facets_unavailable", "gitlab_resource_facets_unavailable", "provider_unavailable_local_only"}
 USER_PROFILE_SIDECAR = Path("user-profile/preferences.md")
 PROCEDURE_SIDECAR_DIRECTORY = "procedure-memory"
 PLACEHOLDER_RE = re.compile(r"\[([^\]\n]+)\]")
@@ -128,6 +129,10 @@ def validate_json(path: Path, memory: Path, errors: list[str], checked: list[str
         errors.append(f"{relative(path, memory)}: could not read JSON: {exc}")
 
 
+def raw_source_points_to_provider(raw_source: Any) -> bool:
+    return isinstance(raw_source, str) and raw_source.endswith(("github-facets.json", "gitlab-facets.json"))
+
+
 def validate_markdown(path: Path, memory: Path, errors: list[str], warnings: list[str], checked: list[str]) -> None:
     checked.append(relative(path, memory))
     try:
@@ -148,7 +153,7 @@ def validate_markdown(path: Path, memory: Path, errors: list[str], warnings: lis
     if path.parent.name != "resources":
         return
 
-    for field in ["resource_count", "raw_source"]:
+    for field in ["source", "resource_count", "trust_state", "raw_source"]:
         if field not in frontmatter:
             errors.append(f"{rel}: frontmatter field '{field}' is missing")
 
@@ -160,6 +165,23 @@ def validate_markdown(path: Path, memory: Path, errors: list[str], warnings: lis
     elif expected is not None:
         errors.append(f"{rel}: resource_count must be an integer")
 
+    source = frontmatter.get("source")
+    raw_source = frontmatter.get("raw_source")
+    if "source" in frontmatter and not source:
+        errors.append(f"{rel}: frontmatter field 'source' must not be empty")
+    if "trust_state" in frontmatter and not frontmatter.get("trust_state"):
+        errors.append(f"{rel}: frontmatter field 'trust_state' must not be empty")
+    if source in DISABLED_RESOURCE_SOURCES and isinstance(expected, int) and expected != 0:
+        errors.append(f"{rel}: disabled or unavailable resource source {source!r} must use resource_count 0")
+    if source in DISABLED_RESOURCE_SOURCES and raw_source:
+        errors.append(f"{rel}: disabled or unavailable resource source {source!r} must use an empty raw_source")
+    if path.name in {"commits.md", "prs.md", "issues.md"} and source not in DISABLED_RESOURCE_SOURCES and raw_source == "":
+        errors.append(f"{rel}: empty raw_source requires a disabled or unavailable source")
+    if path.name in {"prs.md", "issues.md"} and raw_source_points_to_provider(raw_source):
+        provider_path = (path.parent / raw_source).resolve()
+        if not provider_path.exists():
+            errors.append(f"{rel}: provider raw evidence is missing for raw_source {raw_source!r}")
+
 
 def provider_raw_paths(memory: Path) -> list[Path]:
     return [memory / rel for rel in PROVIDER_RAW_FILES if (memory / rel).exists()]

package/lib/memorax-code-dsh-adapter/cordis.patch.yml

@@ -0,0 +1,10 @@
+- insert:
+    - id: memorax-code-skill-filesystem
+      name: '@deepseek-ai/dsh-skill-filesystem'
+      config:
+        providerName: memorax-code-bundled
+        includeDefaultRoots: false
+        watch: false
+        bundledSkillDir: !!js "process.getBuiltinModule('node:url').fileURLToPath(new URL('node_modules/@memorax-code/dsh-memorax-code/skills/', baseUrl))"
+    - id: memorax-code
+      name: '@memorax-code/dsh-memorax-code'

package/lib/memorax-code-dsh-adapter/hooks/repo-memory-job.mjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import { readFileSync, readdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runRepoMemoryJob } from "../memorax-code-adapter-common/src/repo-memory/repo-memory-job-supervisor.mjs";
+import { evaluateRepository } from "../memorax-code-adapter-common/src/repo-memory/repo-memory-update-policy-evaluator.mjs";
+import { requireEnabledDshRuntime } from "../src/runtime-state.mjs";
+
+const ADAPTER_PACKAGE_NAME = "@memorax-code/dsh-memorax-code";
+const HEADLESS_BUNDLE_NAME = "@deepseek-ai/dsh-headless";
+const hookDir = dirname(fileURLToPath(import.meta.url));
+const pluginRoot = dirname(hookDir);
+
+try {
+  const runtime = requireEnabledDshRuntime(pluginRoot);
+  process.env.MEMORAX_CODE_HOME = runtime.memoraxCodeHome;
+  const profile = selectHeadlessProfile(runtime.dshHome, runtime.profiles);
+  if (!profile) throw new Error("no existing DSH headless-capable profile is available");
+  const payload = runRepoMemoryJob(process.argv.slice(2), {
+    runner: "dsh",
+    finalMessageSource: "stdout",
+    memorySkillInvocation: "/memorax-code",
+    validatorPath: resolve(pluginRoot, "skills/memorax-code/scripts/validate_memory.py"),
+    evaluateRepository,
+    createCommand({ prompt }) {
+      return [runtime.dshCommand, "--profile", profile, prompt];
+    },
+  });
+  process.stdout.write(`${JSON.stringify(payload)}\n`);
+} catch (error) {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  process.exit(1);
+}
+
+function selectHeadlessProfile(dshHome, managedProfiles) {
+  const profilesRoot = join(dshHome, "profiles");
+  const managedNames = new Set(managedProfiles);
+  let entries;
+  try {
+    entries = readdirSync(profilesRoot, { withFileTypes: true });
+  } catch {
+    return undefined;
+  }
+  for (const entry of entries
+    .filter((candidate) => candidate.isDirectory()
+      && managedNames.has(candidate.name)
+      && validProfileName(candidate.name))
+    .sort((left, right) => left.name.localeCompare(right.name))) {
+    try {
+      const manifest = JSON.parse(readFileSync(join(profilesRoot, entry.name, "package.json"), "utf8"));
+      const bundles = manifest?.dsh?.profile?.bundles;
+      if (Array.isArray(bundles)
+        && bundles.includes(HEADLESS_BUNDLE_NAME)
+        && bundles.includes(ADAPTER_PACKAGE_NAME)
+        && Object.hasOwn(manifest.dependencies || {}, ADAPTER_PACKAGE_NAME)) {
+        return entry.name;
+      }
+    } catch {
+      // Ignore invalid or concurrently replaced Profiles.
+    }
+  }
+  return undefined;
+}
+
+function validProfileName(value) {
+  return value && value !== "." && value !== ".." && value !== "node_modules"
+    && !value.includes("/") && !value.includes("\\");
+}