@misterhuydo/sentinel 1.5.4 → 1.5.6

package/.cairn/views/62a614_bundle.js

@@ -11,7 +11,10 @@ const copies = [
 ];
 console.log('Bundling Python source into cli/python/...');
 for (const { src, dst } of copies) {
-  fs.copySync(src, dst, { overwrite: true });
+  fs.copySync(src, dst, {
+    overwrite: true,
+    filter: (src) => !src.includes('__pycache__'),
+  });
   console.log('  ' + path.relative(CLI_DIR, src) + ' -> ' + path.relative(CLI_DIR, dst));
 }
 console.log('Done.');

package/.cairn/views/7802b9_cicd_trigger.py

@@ -0,0 +1,171 @@
+import logging
+import re
+import time
+from pathlib import Path
+import requests
+from .config_loader import RepoConfig
+from .state_store import StateStore
+logger = logging.getLogger(__name__)
+JENKINS_RELEASE_TIMEOUT = 900
+JENKINS_POLL_INTERVAL   = 20
+def trigger(repo: RepoConfig, store: StateStore, fingerprint: str, wait: bool = False) -> bool:
+    if not repo.cicd_type or not repo.cicd_job_url:
+        return True
+    cicd_type = repo.cicd_type.lower()
+    if cicd_type == "jenkins":
+        return _trigger_jenkins(repo)
+    elif cicd_type in ("jenkins_release", "jenkins-release"):
+        return _trigger_jenkins_release(repo, wait=wait)
+    elif cicd_type in ("github_actions", "github-actions"):
+        return _trigger_github_actions(repo, fingerprint)
+    else:
+        logger.warning("Unknown CICD_TYPE '%s' for %s", repo.cicd_type, repo.repo_name)
+        return False
+def _trigger_jenkins(repo: RepoConfig) -> bool:
+    url = f"{repo.cicd_job_url.rstrip('/')}/build"
+    resp = requests.post(url, auth=("sentinel", repo.cicd_token), timeout=15)
+    success = resp.status_code in (200, 201, 204)
+    if success:
+        logger.info("Jenkins build triggered: %s", repo.cicd_job_url)
+    else:
+        logger.error("Jenkins trigger failed (%s): %s", resp.status_code, resp.text[:200])
+    return success
+def _get_last_build_number(session: requests.Session, job_url: str) -> int:
+    try:
+        r = session.get(f"{job_url.rstrip('/')}/api/json", timeout=10)
+        data = r.json()
+        lb = data.get("lastBuild")
+        return lb["number"] if lb else 0
+    except Exception as exc:
+        logger.warning("Could not get last build number for %s: %s", job_url, exc)
+        return 0
+def _wait_for_jenkins_build(
+    session: requests.Session,
+    job_url: str,
+    prev_build_num: int,
+    timeout: int = JENKINS_RELEASE_TIMEOUT,
+) -> bool:
+    deadline = time.time() + timeout
+    build_num = None
+    while time.time() < deadline:
+        current = _get_last_build_number(session, job_url)
+        if current > prev_build_num:
+            build_num = current
+            logger.info("Jenkins build
+            break
+        logger.debug("Waiting for Jenkins build to start (last=%d)...", current)
+        time.sleep(JENKINS_POLL_INTERVAL)
+    else:
+        logger.error("Timed out waiting for Jenkins build to start: %s", job_url)
+        return False
+    build_api = f"{job_url.rstrip('/')}/{build_num}/api/json"
+    while time.time() < deadline:
+        try:
+            r = session.get(build_api, timeout=10)
+            data = r.json()
+            if not data.get("building", True):
+                result = data.get("result", "UNKNOWN")
+                if result == "SUCCESS":
+                    logger.info("Jenkins build
+                    return True
+                else:
+                    logger.error("Jenkins build
+                    return False
+            elapsed = int(time.time() - (deadline - timeout))
+            logger.info("Jenkins build
+        except Exception as exc:
+            logger.warning("Jenkins poll error for %s: %s", build_api, exc)
+        time.sleep(JENKINS_POLL_INTERVAL)
+    logger.error("Timed out waiting for Jenkins build
+    return False
+def _trigger_jenkins_release(repo: RepoConfig, wait: bool = False) -> bool:
+    release_ver, dev_ver = _maven_release_versions(repo.local_path)
+    if not release_ver:
+        logger.error("Jenkins release: could not determine release version from pom.xml")
+        return False
+    url = f"{repo.cicd_job_url.rstrip('/')}/m2release/submit"
+    auth = (repo.cicd_user or "sentinel", repo.cicd_token)
+    session = requests.Session()
+    session.auth = auth
+    from urllib.parse import urlparse
+    parsed = urlparse(repo.cicd_job_url)
+    jenkins_root = f"{parsed.scheme}://{parsed.netloc}"
+    crumb_data = session.get(f"{jenkins_root}/crumbIssuer/api/json", timeout=10).json()
+    crumb_header = {crumb_data["crumbRequestField"]: crumb_data["crumb"]}
+    prev_build_num = _get_last_build_number(session, repo.cicd_job_url) if wait else 0
+    scm_tag = f"{repo.repo_name}-{release_ver}"
+    import json as _json
+    stapler_json = _json.dumps({
+        "releaseVersion":        release_ver,
+        "developmentVersion":    dev_ver,
+        "isDryRun":              False,
+        "specifyScmCredentials": False,
+        "scmUsername":           "",
+        "scmCommentPrefix":      "[maven-release-plugin] ",
+        "appendHudsonUserName":  False,
+        "specifyScmTag":         False,
+        "scmTag":                scm_tag,
+    })
+    resp = session.post(
+        url,
+        headers={
+            **crumb_header,
+            "Referer": f"{repo.cicd_job_url.rstrip('/')}/m2release/",
+        },
+        data={
+            "releaseVersion":     release_ver,
+            "developmentVersion": dev_ver,
+            "scmCommentPrefix":   "[maven-release-plugin] ",
+            "scmTag":             scm_tag,
+            "json":               stapler_json,
+        },
+        timeout=15,
+        allow_redirects=False,
+    )
+    triggered = resp.status_code in (200, 201, 204, 302)
+    if not triggered:
+        logger.error("Jenkins release trigger failed (%s): %s", resp.status_code, resp.text[:200])
+        return False
+    logger.info(
+        "Jenkins Maven Release triggered: %s → %s (next: %s)%s",
+        repo.cicd_job_url, release_ver, dev_ver,
+        " — waiting for completion..." if wait else "",
+    )
+    if wait:
+        return _wait_for_jenkins_build(session, repo.cicd_job_url, prev_build_num)
+    return True
+def _maven_release_versions(local_path: str) -> tuple[str, str]:
+    pom = Path(local_path) / "pom.xml"
+    if not pom.exists():
+        return ("", "")
+    text = pom.read_text(encoding="utf-8", errors="ignore")
+    m = re.search(r"<version>(\d+\.\d+\.\d+)-SNAPSHOT</version>", text)
+    if not m:
+        return ("", "")
+    parts = m.group(1).split(".")
+    release_ver = m.group(1)
+    next_patch = int(parts[2]) + 1
+    dev_ver = f"{parts[0]}.{parts[1]}.{next_patch}-SNAPSHOT"
+    return release_ver, dev_ver
+def _trigger_github_actions(repo: RepoConfig, fingerprint: str) -> bool:
+    owner_repo = _owner_repo(repo.repo_url)
+    url = f"https://api.github.com/repos/{owner_repo}/dispatches"
+    resp = requests.post(
+        url,
+        json={"event_type": "sentinel-deploy", "client_payload": {"fingerprint": fingerprint}},
+        headers={
+            "Authorization": f"Bearer {repo.cicd_token}",
+            "Accept": "application/vnd.github+json",
+        },
+        timeout=15,
+    )
+    success = resp.status_code == 204
+    if success:
+        logger.info("GitHub Actions dispatch sent for %s", owner_repo)
+    else:
+        logger.error("GH Actions dispatch failed (%s): %s", resp.status_code, resp.text[:200])
+    return success
+def _owner_repo(repo_url: str) -> str:
+    if repo_url.startswith("git@"):
+        return repo_url.split(":")[-1].removesuffix(".git")
+    return "/".join(repo_url.rstrip("/").split("/")[-2:]).removesuffix(".git")

package/.cairn/views/ac3df4_repo_task_engine.py

@@ -0,0 +1,351 @@
+from __future__ import annotations
+import hashlib
+import logging
+import re
+import subprocess
+import time
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from .config_loader import RepoConfig, SentinelConfig
+from .fix_engine import _claude_cmd, _run_claude_attempt, _is_auth_error, _progress_from_line
+from .git_manager import _git_env
+logger = logging.getLogger(__name__)
+_META_PREFIXES = ("REPO:", "TYPE:", "SUBMITTED_BY:", "SUBMITTED_AT:", "NOTIFY:")
+_TASK_TIMEOUT = 900
+@dataclass
+class RepoTask:
+    task_file: Path
+    repo_name: str
+    task_type: str
+    description: str
+    message: str
+    submitter_user_id: str = ""
+    notify_user_ids: list = field(default_factory=list)
+    fingerprint: str = ""
+    timestamp: str = ""
+    def __post_init__(self):
+        if not self.fingerprint:
+            raw = f"repo-task:{self.repo_name}:{self.task_type}:{self.message[:200]}"
+            self.fingerprint = hashlib.sha1(raw.encode()).hexdigest()[:16]
+        if not self.timestamp:
+            self.timestamp = datetime.now(timezone.utc).isoformat()
+def _build_repo_prompt(task: RepoTask, repo: RepoConfig) -> str:
+    submitted = f"Requested by: <@{task.submitter_user_id}>" if task.submitter_user_id else ""
+    return (
+        f"You are implementing a requested change in the repository at {repo.local_path}.\n"
+        f"Repository: {repo.repo_name}\n"
+        f"{submitted}\n"
+        f"\n"
+        f"TASK TYPE: {task.task_type}\n"
+        f"TASK:\n{task.description}\n\n"
+        f"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
+        f"INSTRUCTIONS\n"
+        f"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
+        f"1. Explore the codebase first — understand structure, patterns, and conventions\n"
+        f"   before making any changes.\n"
+        f"2. Implement the requested change following the repo's existing code style.\n"
+        f"3. Syntax/compile check modified files.\n"
+        f"4. Run tests if available (Maven, Gradle, npm test) — commit only if passing.\n"
+        f"5. Commit all changes:\n"
+        f"   git add -A\n"
+        f"   git commit -m \"{task.task_type}(<scope>): <concise summary> [sentinel-task]\"\n"
+        f"6. End with a brief summary (max 10 lines) of what changed and why.\n"
+        f"\n"
+        f"BOUNDARIES:\n"
+        f"- Never modify CI/CD config files (.github/, Jenkinsfile, pom.xml build sections)\n"
+        f"- Implement exactly what was requested — no extra scope\n"
+        f"- If the task requires information you don't have:\n"
+        f"  output exactly: NEEDS_HUMAN: <what is missing>\n"
+        f"- If implementing this requires changing Sentinel itself (not this repo):\n"
+        f"  output exactly: BOSS_ESCALATE: <description>\n"
+    )
+def _get_head(local_path: str, env: dict) -> str:
+    r = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=local_path, capture_output=True, text=True, env=env, timeout=10,
+    )
+    return r.stdout.strip() if r.returncode == 0 else ""
+def _open_task_pr(repo: RepoConfig, cfg: SentinelConfig, branch: str, task: RepoTask, commit_hash: str) -> str:
+    if not cfg.github_token:
+        logger.warning("GITHUB_TOKEN not set — cannot open PR for repo task")
+        return ""
+    url = repo.repo_url
+    owner_repo = (
+        url.split(":")[-1].removesuffix(".git") if url.startswith("git@")
+        else "/".join(url.rstrip("/").split("/")[-2:]).removesuffix(".git")
+    )
+    title = f"[Sentinel] {task.task_type}({repo.repo_name}): {task.message[:60]}"
+    submitter_line = f"**Requested by:** <@{task.submitter_user_id}>\n" if task.submitter_user_id else ""
+    body = (
+        f"
+        f"**Task type:** `{task.task_type}`\n"
+        f"{submitter_line}"
+        f"**Commit:** `{commit_hash[:8]}`\n\n"
+        f"
+        f"---\n_Implemented by Sentinel. Review and merge when satisfied._"
+    )
+    import requests as _req
+    resp = _req.post(
+        f"https://api.github.com/repos/{owner_repo}/pulls",
+        json={"title": title, "body": body, "head": branch, "base": repo.branch},
+        headers={"Authorization": f"Bearer {cfg.github_token}", "Accept": "application/vnd.github+json"},
+        timeout=30,
+    )
+    if resp.status_code == 201:
+        pr_url = resp.json().get("html_url", "")
+        logger.info("Task PR opened: %s", pr_url)
+        return pr_url
+    logger.error("Failed to open task PR (%s): %s", resp.status_code, resp.text[:300])
+    return ""
+def run_repo_task(
+    task: RepoTask,
+    repo: RepoConfig,
+    cfg: SentinelConfig,
+    store=None,
+    on_progress=None,
+) -> tuple[str, str | None]:
+    local_path = repo.local_path
+    if not local_path or not Path(local_path).exists():
+        return "error", f"Local clone not found at {local_path!r} — run `sentinel init` first"
+    env = _git_env(repo)
+    r = subprocess.run(
+        ["git", "pull", "--rebase", "origin", repo.branch],
+        cwd=local_path, capture_output=True, text=True, env=env, timeout=60,
+    )
+    if r.returncode != 0:
+        logger.warning("git pull failed before repo task for %s: %s", repo.repo_name, r.stderr[:200])
+    before_hash = _get_head(local_path, env)
+    prompt = _build_repo_prompt(task, repo)
+    claude_log = Path(local_path).parent / "logs" / f"repo-task-{task.fingerprint[:8]}.log"
+    claude_log.parent.mkdir(parents=True, exist_ok=True)
+    if on_progress:
+        on_progress(f":mag: Exploring `{repo.repo_name}`...")
+    import os as _os
+    skip_perms = _os.getuid() != 0
+    oauth_cmd = (
+        [cfg.claude_code_bin, "--dangerously-skip-permissions", "--print", prompt]
+        if skip_perms else
+        [cfg.claude_code_bin, "--print", prompt]
+    )
+    api_cmd = (
+        [cfg.claude_code_bin, "--dangerously-skip-permissions", "--bare", "--print", prompt]
+        if skip_perms else
+        [cfg.claude_code_bin, "--bare", "--print", prompt]
+    )
+    api_env = {**env, "ANTHROPIC_API_KEY": cfg.anthropic_api_key} if cfg.anthropic_api_key else None
+    try:
+        output, timed_out = _run_claude_attempt(
+            cfg.claude_code_bin, prompt, env,
+            cwd=local_path, claude_log_path=claude_log, on_progress=on_progress,
+            cmd_override=oauth_cmd,
+        )
+    except FileNotFoundError:
+        return "error", f"Claude binary not found: {cfg.claude_code_bin}"
+    if timed_out:
+        return "error", "Claude timed out after 15 minutes."
+    stripped = output.strip()
+    if _is_auth_error(stripped):
+        if api_env:
+            logger.warning("repo_task/%s: OAuth session issue — retrying with API key", repo.repo_name)
+            if on_progress:
+                on_progress(":key: Auth refreshed — retrying...")
+            try:
+                output, timed_out = _run_claude_attempt(
+                    cfg.claude_code_bin, prompt, api_env,
+                    cwd=local_path, claude_log_path=claude_log, on_progress=on_progress,
+                    cmd_override=api_cmd,
+                )
+            except FileNotFoundError:
+                return "error", f"Claude binary not found: {cfg.claude_code_bin}"
+            if timed_out:
+                return "error", "Claude timed out after 15 minutes."
+            stripped = output.strip()
+            if _is_auth_error(stripped):
+                return "error", "Claude authentication failed — check ANTHROPIC_API_KEY."
+        else:
+            return "error", "Claude authentication error — run `claude login` on the server or set ANTHROPIC_API_KEY."
+    if stripped.upper().startswith("SKIP:"):
+        reason = stripped[5:].strip()
+        logger.info("Repo task skipped for %s: %s", repo.repo_name, reason[:200])
+        return "skip", reason
+    if stripped.upper().startswith("NEEDS_HUMAN:"):
+        reason = stripped[12:].strip()
+        logger.info("Repo task needs human for %s: %s", repo.repo_name, reason[:200])
+        return "needs_human", reason
+    if stripped.upper().startswith("BOSS_ESCALATE:"):
+        description = stripped[14:].strip()
+        try:
+            from .sentinel_dev import drop_escalation
+            drop_escalation(
+                Path(local_path).parent,
+                description,
+                source="repo_task/BOSS_ESCALATE",
+                source_fingerprint=task.fingerprint,
+            )
+            logger.info("Repo task escalated to Patch for %s: %s", repo.repo_name, description[:200])
+        except Exception as _e:
+            logger.error("Failed to drop BOSS_ESCALATE from repo task: %s", _e)
+        return "skip", f"Escalated to Patch: {description[:200]}"
+    after_hash = _get_head(local_path, env)
+    if after_hash == before_hash:
+        diff_r = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=local_path, capture_output=True, text=True, env=env, timeout=10,
+        )
+        if diff_r.stdout.strip():
+            commit_msg = f"{task.task_type}(sentinel-task): {task.message[:60]} [sentinel-task]"
+            subprocess.run(["git", "add", "-A"], cwd=local_path, env=env, timeout=30, capture_output=True)
+            cr = subprocess.run(
+                ["git", "commit", "-m", commit_msg],
+                cwd=local_path, env=env, timeout=30, capture_output=True, text=True,
+            )
+            if cr.returncode != 0:
+                logger.error("Auto-commit failed for %s: %s", repo.repo_name, cr.stderr[:200])
+                subprocess.run(["git", "checkout", "."], cwd=local_path, env=env, timeout=30, capture_output=True)
+                return "error", "Claude made changes but commit failed."
+            after_hash = _get_head(local_path, env)
+        else:
+            logger.warning("Repo task: Claude ran but made no changes for %s", repo.repo_name)
+            return "skip", "Claude completed but made no changes to the codebase."
+    commit_hash = after_hash
+    if on_progress:
+        on_progress(f":arrow_up: Pushing to `{repo.repo_name}`...")
+    if repo.auto_publish:
+        r = subprocess.run(
+            ["git", "push", "origin", repo.branch],
+            cwd=local_path, capture_output=True, text=True, env=env, timeout=60,
+        )
+        if r.returncode != 0:
+            logger.error("git push failed for %s: %s", repo.repo_name, r.stderr[:300])
+            return "error", f"git push failed: {r.stderr.strip()[:200]}"
+        logger.info("Repo task: pushed to %s/%s sha=%s", repo.repo_name, repo.branch, commit_hash[:8])
+        if repo.cicd_type:
+            try:
+                from .cicd_trigger import trigger as cicd_trigger
+                ok = cicd_trigger(repo, None, task.fingerprint)
+                if ok:
+                    logger.info("Repo task: CI/CD triggered for %s (%s)", repo.repo_name, repo.cicd_type)
+                    if on_progress:
+                        on_progress(f":rocket: Release triggered via `{repo.cicd_type}`")
+                    return "done", f"__cicd__{repo.cicd_type}"
+                else:
+                    logger.warning("Repo task: CI/CD trigger failed for %s", repo.repo_name)
+                    if on_progress:
+                        on_progress(f":warning: CI/CD trigger failed for `{repo.cicd_type}` — check logs")
+            except Exception as exc:
+                logger.warning("Repo task: CI/CD trigger failed for %s: %s", repo.repo_name, exc)
+                if on_progress:
+                    on_progress(f":warning: CI/CD trigger error — {exc}")
+        return "done", None
+    else:
+        branch = f"sentinel/task-{task.fingerprint[:8]}"
+        subprocess.run(["git", "checkout", "-B", branch], cwd=local_path, env=env,
+                       timeout=30, capture_output=True)
+        r = subprocess.run(
+            ["git", "push", "-u", "origin", branch],
+            cwd=local_path, capture_output=True, text=True, env=env, timeout=60,
+        )
+        if r.returncode != 0:
+            logger.error("git push branch failed for %s: %s", repo.repo_name, r.stderr[:300])
+            subprocess.run(["git", "checkout", repo.branch], cwd=local_path, env=env,
+                           timeout=30, capture_output=True)
+            return "error", f"git push failed: {r.stderr.strip()[:200]}"
+        subprocess.run(["git", "checkout", repo.branch], cwd=local_path, env=env,
+                       timeout=30, capture_output=True)
+        pr_url = _open_task_pr(repo, cfg, branch, task, commit_hash)
+        logger.info("Repo task: PR opened for %s: %s", repo.repo_name, pr_url)
+        return "done", pr_url or None
+def drop_repo_task(
+    project_dir: Path,
+    repo_name: str,
+    task_type: str,
+    description: str,
+    submitter_user_id: str = "",
+    notify_user_ids: list | None = None,
+) -> Path:
+    tasks_dir = project_dir / "repo-tasks"
+    tasks_dir.mkdir(exist_ok=True)
+    import uuid as _uuid
+    ts = int(time.time())
+    fname = f"{repo_name}-{_uuid.uuid4().hex[:8]}-{ts}.txt"
+    fpath = tasks_dir / fname
+    lines = [
+        f"REPO: {repo_name}",
+        f"TYPE: {task_type}",
+        (f"SUBMITTED_BY: <@{submitter_user_id}> ({submitter_user_id})"
+         if submitter_user_id else "SUBMITTED_BY: system"),
+        f"SUBMITTED_AT: {datetime.now(timezone.utc).isoformat()}",
+    ]
+    if notify_user_ids:
+        lines.append(f"NOTIFY: {','.join(notify_user_ids)}")
+    lines += ["", description]
+    fpath.write_text("\n".join(lines), encoding="utf-8")
+    logger.info("Dropped repo task: %s", fname)
+    return fpath
+def scan_repo_tasks(project_dir: Path) -> list[RepoTask]:
+    tasks_dir = project_dir / "repo-tasks"
+    if not tasks_dir.exists():
+        return []
+    tasks = []
+    for f in sorted(tasks_dir.iterdir()):
+        if not f.is_file() or f.name.startswith(".") or f.suffix.lower() not in (".txt", ".md", ""):
+            continue
+        try:
+            content = f.read_text(encoding="utf-8", errors="replace").strip()
+        except OSError:
+            continue
+        if not content:
+            continue
+        lines = content.splitlines()
+        repo_name = ""
+        task_type = "feature"
+        submitter_user_id = ""
+        notify_user_ids: list = []
+        body_start = 0
+        for i, line in enumerate(lines):
+            stripped = line.strip()
+            upper = stripped.upper()
+            if upper.startswith("REPO:"):
+                repo_name = stripped[5:].strip()
+                body_start = i + 1
+            elif upper.startswith("TYPE:"):
+                raw = stripped[5:].strip().lower()
+                task_type = raw if raw in ("feature", "fix", "refactor", "chore") else "feature"
+                body_start = i + 1
+            elif upper.startswith("SUBMITTED_BY:"):
+                m = re.search(r'\(([UW][A-Z0-9]+)\)', stripped)
+                if m:
+                    submitter_user_id = m.group(1)
+                body_start = i + 1
+            elif upper.startswith("NOTIFY:"):
+                notify_user_ids = [u.strip() for u in stripped[7:].split(",") if u.strip()]
+                body_start = i + 1
+            elif any(upper.startswith(p) for p in _META_PREFIXES) or not stripped:
+                body_start = i + 1
+            else:
+                break
+        description = "\n".join(lines[body_start:]).strip() or content
+        message = next((l.strip() for l in lines[body_start:] if l.strip()), f.name)
+        if not repo_name:
+            logger.warning("Repo task %s has no REPO: header — skipping", f.name)
+            continue
+        tasks.append(RepoTask(
+            task_file=f,
+            repo_name=repo_name,
+            task_type=task_type,
+            description=description,
+            message=message,
+            submitter_user_id=submitter_user_id,
+            notify_user_ids=notify_user_ids,
+        ))
+        logger.info("Found repo task: %s → %s (type=%s)", f.name, repo_name, task_type)
+    return tasks
+def mark_repo_task_done(task_file: Path) -> None:
+    done_dir = task_file.parent / ".done"
+    done_dir.mkdir(exist_ok=True)
+    dest = done_dir / task_file.name
+    if dest.exists():
+        dest = done_dir / f"{task_file.stem}-{int(time.time())}{task_file.suffix}"
+    task_file.rename(dest)
+    logger.info("Repo task archived: %s -> .done/%s", task_file.name, dest.name)

package/lib/.cairn/minify-map.json

@@ -4,5 +4,11 @@
     "state": "compressed",
     "minifiedAt": 1774252437350.0059,
     "readCount": 1
+  },
+  "J:\\Projects\\Sentinel\\cli\\lib\\upgrade.js": {
+    "tempPath": "J:\\Projects\\Sentinel\\cli\\lib\\.cairn\\views\\fb78ac_upgrade.js",
+    "state": "compressed",
+    "minifiedAt": 1774773534448.1794,
+    "readCount": 1
   }
 }