skillctl-secure 0.28.2__tar.gz → 0.29.0__tar.gz

{skillctl_secure-0.28.2 → skillctl_secure-0.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: skillctl-secure
-Version: 0.28.2
+Version: 0.29.0
 Summary: Package manager, trust layer, and portability layer for Agent Skills
 Project-URL: Homepage, https://github.com/brian-scardina/skillctl
 Project-URL: Repository, https://github.com/brian-scardina/skillctl
@@ -310,3 +310,71 @@ recovery or schema error.
 - [Environment reconciliation](docs/RECONCILIATION.md)
 - [Upgrade and persisted-format guidance](docs/UPGRADES.md)
 - [CLI/API contract](docs/CLI-CONTRACT.md)
+
+### Choose where a skill is installed
+
+In the TUI, select a skill and choose **Install…**, including when the skill
+is already installed in the active toolbox. Select one or more destinations,
+choose **Review selection**, inspect the source findings and runtime requirements,
+and choose **Apply selected**. **Update** and **Uninstall** also let you select
+which destinations to change. **Update all** applies only to the active toolbox.
+
+The header identifies the current **Toolbox**, which is an isolated skillctl skill
+set. It is separate from an AI app destination. Skill details show the destination
+paths and local status. **Installed locally** means validated files exist; it does
+not establish that an AI session has discovered or executed them. Detection of an
+app/configuration is also separate from discovery of a skill inside the app.
+
+The selector offers personal destinations for Codex, GitHub Copilot, and Claude
+Code. Use **Add destination** for a project or another local installation, specifying
+the app and its actual skill directory. For example, use `/repo/.github/skills`
+for a GitHub Copilot project. Shared directories are written once; removing a
+shared copy can affect every app reading that directory. Unmanaged or locally
+modified files are protected from replacement and removal.
+
+**Microsoft 365 Copilot Cowork** is a separate destination from GitHub Copilot and
+ordinary Copilot Chat. The installer prepares ZIP packages with `SKILL.md` at the
+archive root. In Cowork, use **Customize → Skills → Add → Upload skill**, including
+packages for required dependencies. Status remains **Import required**; local
+packaging does not confirm import or runtime compatibility. Test in a new
+conversation. Removing the local export does not remove the imported Cowork skill.
+See [Microsoft's Cowork import documentation](https://learn.microsoft.com/en-us/microsoft-365/copilot/cowork/cowork-customize).
+
+CLI equivalents:
+
+```bash
+skillctl destinations archify
+skillctl install-to archify --target codex --target github-copilot
+skillctl install-to archify --target codex --target github-copilot --apply
+skillctl install-to archify --target github-copilot --operation update --apply
+skillctl install-to archify --target github-copilot --operation remove --apply
+```
+
+Without `--apply`, `install-to` only reviews the selected destinations. REVIEW
+items additionally require `--approve-review`; DENY items remain blocked.
+Operations complete independently by destination, so inspect each result when
+some destinations fail. Existing `install` and collection commands continue to
+use the active toolbox.
+
+### Discover skills already on this computer
+
+Startup and **Ctrl+R** scan known local skill directories automatically. Open
+**Skills → Inventory** (or the inventory row on Home) to see skills installed by
+skillctl, another installer, or manual copying—even when they are absent from the
+source catalog. **Installed here** remains scoped to the active toolbox.
+
+Inventory shows each physical copy's app destinations, paths, description,
+version when available, and ownership. Shared directories and linked aliases are
+grouped; independent copies remain separate. Invalid metadata, unreadable roots,
+and missing files with an installation record are reported. Audit-only catalog
+records do not count as installed skills.
+
+Discovery reads bounded `SKILL.md` metadata from supported personal directories,
+Codex's system-skill directory, the launch directory's standard project skill
+folders, registered project destinations, and named toolboxes. It does not walk
+the entire disk, infer installed plugins from cached versions, execute skill
+instructions, or take ownership of external files. Cloud/account imports and
+actual discovery inside an AI session remain unverified.
+
+Use `skillctl inventory` or `skillctl inventory --json` for the same discovery from
+the command line. JSON output also includes scan time, checked roots, and errors.

{skillctl_secure-0.28.2 → skillctl_secure-0.29.0}/README.md

@@ -286,3 +286,71 @@ recovery or schema error.
 - [Environment reconciliation](docs/RECONCILIATION.md)
 - [Upgrade and persisted-format guidance](docs/UPGRADES.md)
 - [CLI/API contract](docs/CLI-CONTRACT.md)
+
+### Choose where a skill is installed
+
+In the TUI, select a skill and choose **Install…**, including when the skill
+is already installed in the active toolbox. Select one or more destinations,
+choose **Review selection**, inspect the source findings and runtime requirements,
+and choose **Apply selected**. **Update** and **Uninstall** also let you select
+which destinations to change. **Update all** applies only to the active toolbox.
+
+The header identifies the current **Toolbox**, which is an isolated skillctl skill
+set. It is separate from an AI app destination. Skill details show the destination
+paths and local status. **Installed locally** means validated files exist; it does
+not establish that an AI session has discovered or executed them. Detection of an
+app/configuration is also separate from discovery of a skill inside the app.
+
+The selector offers personal destinations for Codex, GitHub Copilot, and Claude
+Code. Use **Add destination** for a project or another local installation, specifying
+the app and its actual skill directory. For example, use `/repo/.github/skills`
+for a GitHub Copilot project. Shared directories are written once; removing a
+shared copy can affect every app reading that directory. Unmanaged or locally
+modified files are protected from replacement and removal.
+
+**Microsoft 365 Copilot Cowork** is a separate destination from GitHub Copilot and
+ordinary Copilot Chat. The installer prepares ZIP packages with `SKILL.md` at the
+archive root. In Cowork, use **Customize → Skills → Add → Upload skill**, including
+packages for required dependencies. Status remains **Import required**; local
+packaging does not confirm import or runtime compatibility. Test in a new
+conversation. Removing the local export does not remove the imported Cowork skill.
+See [Microsoft's Cowork import documentation](https://learn.microsoft.com/en-us/microsoft-365/copilot/cowork/cowork-customize).
+
+CLI equivalents:
+
+```bash
+skillctl destinations archify
+skillctl install-to archify --target codex --target github-copilot
+skillctl install-to archify --target codex --target github-copilot --apply
+skillctl install-to archify --target github-copilot --operation update --apply
+skillctl install-to archify --target github-copilot --operation remove --apply
+```
+
+Without `--apply`, `install-to` only reviews the selected destinations. REVIEW
+items additionally require `--approve-review`; DENY items remain blocked.
+Operations complete independently by destination, so inspect each result when
+some destinations fail. Existing `install` and collection commands continue to
+use the active toolbox.
+
+### Discover skills already on this computer
+
+Startup and **Ctrl+R** scan known local skill directories automatically. Open
+**Skills → Inventory** (or the inventory row on Home) to see skills installed by
+skillctl, another installer, or manual copying—even when they are absent from the
+source catalog. **Installed here** remains scoped to the active toolbox.
+
+Inventory shows each physical copy's app destinations, paths, description,
+version when available, and ownership. Shared directories and linked aliases are
+grouped; independent copies remain separate. Invalid metadata, unreadable roots,
+and missing files with an installation record are reported. Audit-only catalog
+records do not count as installed skills.
+
+Discovery reads bounded `SKILL.md` metadata from supported personal directories,
+Codex's system-skill directory, the launch directory's standard project skill
+folders, registered project destinations, and named toolboxes. It does not walk
+the entire disk, infer installed plugins from cached versions, execute skill
+instructions, or take ownership of external files. Cloud/account imports and
+actual discovery inside an AI session remain unverified.
+
+Use `skillctl inventory` or `skillctl inventory --json` for the same discovery from
+the command line. JSON output also includes scan time, checked roots, and errors.

{skillctl_secure-0.28.2 → skillctl_secure-0.29.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "skillctl-secure"
-version = "0.28.2"
+version = "0.29.0"
 description = "Package manager, trust layer, and portability layer for Agent Skills"
 readme = "README.md"
 license = "Apache-2.0"

skillctl_secure-0.29.0/skillctl/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.29.0"

{skillctl_secure-0.28.2 → skillctl_secure-0.29.0}/skillctl/compatibility.py

@@ -34,9 +34,13 @@ HOSTS: dict[str, HostSpec] = {
         "Agent Skills-compatible format; some skills may depend on Claude-specific tools.",
     ),
     "microsoft-365-copilot": HostSpec(
-        "microsoft-365-copilot", "Microsoft 365 Copilot", False,
+        "microsoft-365-copilot", "Microsoft 365 Copilot (Chat / Studio adapter)", False,
         (), (),
-        "No local Agent Skills discovery path; explicit export/adapter required.",
+        "Chat does not discover local skill directories. Studio uses the legacy adaptation export; Cowork is a separate import target.",
+    ),
+    "copilot-cowork": HostSpec(
+        "copilot-cowork", "Microsoft 365 Copilot Cowork", True, (), (),
+        "Import SKILL.md or a ZIP through Customize → Skills → Upload skill; files are saved to OneDrive. Local file placement is not app discovery.",
     ),
 }
 
@@ -222,6 +226,15 @@ def evaluate_skill(skill_dir: Path | None, host_id: str, publisher_note: str = "
     host = HOSTS[host_id]
     observed = collect_evidence(skill_dir, publisher_note)
 
+    if host_id == "copilot-cowork":
+        return {
+            "host": host_id, "host_name": host.name, "format": "import-required",
+            "runtime": "unknown", "confidence": "medium",
+            "reasons": ["Explicit Cowork skill import is required; ordinary Copilot Chat is a separate surface.",
+                        "Review companion scripts, tools, connectors, and credentials before use. Import does not establish runtime compatibility."],
+            **observed,
+        }
+
     if not host.agent_skills:
         return {
             "host": host_id,

skillctl_secure-0.29.0/skillctl/destinations.py

@@ -0,0 +1,324 @@
+"""Explicit destinations, independent of the active skillctl toolbox.
+
+Discovery is filesystem/CLI evidence, never proof that an AI session loaded a skill.
+"""
+from __future__ import annotations
+
+from copy import copy, deepcopy
+from dataclasses import dataclass, field, replace
+import hashlib
+import os
+from pathlib import Path
+import re
+import shutil
+import threading
+import zipfile
+
+from .bulk_update import UpdateBatch, UpdateItem, _scope, apply_updates
+from .lockfile import Lockfile
+from .operation_lock import exclusive_operation
+from .stateio import load_json_state, save_json_state
+
+
+@dataclass(frozen=True)
+class Destination:
+    id: str
+    label: str
+    root: Path
+    host: str = ""
+    mode: str = "local"
+    detected: bool = False
+    scope: str = "Personal"
+
+
+def registry_path():
+    return Path.home() / ".skillctl" / "destinations.json"
+
+
+def known_destinations(manager, name=None):
+    home = Path.home()
+    options = [Destination("toolbox", f"Toolbox: {manager.active_environment}", manager.install_dir, detected=True, scope="Toolbox")]
+    for key, label, folder, command in (
+        ("codex", "OpenAI Codex", ".agents/skills", "codex"),
+        ("github-copilot", "GitHub Copilot", ".copilot/skills", "copilot"),
+        ("claude-code", "Claude Code", ".claude/skills", "claude"),
+    ):
+        app_folder = home / {"codex": ".codex", "github-copilot": ".copilot", "claude-code": ".claude"}[key]
+        root = home / folder
+        if key == "github-copilot" and name and not (root / name).exists() and (home / ".agents/skills" / name / "SKILL.md").is_file():
+            root = home / ".agents/skills"
+            label += " (shared directory)"
+        options.append(Destination(key, label, root, key, detected=app_folder.is_dir() or shutil.which(command) is not None or (Path("/Applications") / {"codex": "Codex.app", "github-copilot": "GitHub Copilot.app", "claude-code": "Claude Code.app"}[key]).is_dir()))
+    options.append(Destination("copilot-cowork", "Microsoft 365 Copilot Cowork", home / ".skillctl" / "exports" / "cowork" / "skills", "copilot-cowork", "import", scope="Account import"))
+    saved = load_json_state(registry_path())
+    for item in saved.get("destinations", []):
+        options.append(Destination(**{**item, "root": Path(item["root"])}))
+    return options
+
+
+@exclusive_operation
+def add_destination(label, root, host, scope="Project"):
+    root = Path(root).expanduser()
+    if not label.strip() or not root.is_absolute():
+        raise ValueError("Enter a name and an absolute skill directory path.")
+    if host not in {"codex", "github-copilot", "claude-code"}:
+        raise ValueError("Choose a supported local AI app.")
+    root = root.absolute()
+    if root == Path(root.anchor) or root == Path.home() or root.is_file():
+        raise ValueError("Choose a dedicated skill directory, not a home directory, drive root, or file.")
+    key = "custom-" + hashlib.sha256(str(root).encode()).hexdigest()[:16]
+    state = load_json_state(registry_path())
+    entries = state.setdefault("destinations", [])
+    entries[:] = [item for item in entries if item["id"] != key]
+    entries.append(dict(id=key, label=label.strip(), root=str(root), host=host, mode="local", detected=False, scope=scope))
+    save_json_state(registry_path(), state)
+    return key
+
+
+def destination_manager(manager, destination):
+    """Independent state and transactions; never switch the user's active toolbox."""
+    clone = copy(manager)
+    clone._skill_transaction_state = threading.local()
+    clone.config = deepcopy(manager.config)
+    # A destination must not rewrite membership of the active named toolbox.
+    clone.sync_environment_membership = lambda: None
+    clone.install_dir = destination.root.expanduser().absolute()
+    # Reuse ownership records for existing toolboxes, including the legacy default.
+    roots = [(manager.install_dir, manager.state_file, manager.lockfile.path, manager.backup_dir),
+             (manager._base_install_dir, manager._base_state_file, manager._base_lockfile, manager.backup_dir)]
+    for item in manager.environment_store.load().get("environments", {}).values():
+        roots.append((Path(item["install_dir"]), Path(item["state_file"]), Path(item["lockfile"]), Path(item["install_dir"]).parent / "backups"))
+    for root, state, lock, backup in roots:
+        if Path(root).resolve() == clone.install_dir.resolve():
+            clone.state_file, clone.lockfile, clone.backup_dir = Path(state), Lockfile(Path(lock)), Path(backup)
+            if Path(root).resolve() == manager.install_dir.resolve():
+                clone.sync_environment_membership = type(manager).sync_environment_membership.__get__(clone)
+            return clone
+    identity = hashlib.sha256(str(clone.install_dir.resolve()).encode()).hexdigest()
+    base = Path.home() / ".skillctl" / "destinations" / identity
+    clone.state_file, clone.lockfile, clone.backup_dir = base / "state.json", Lockfile(base / "skills.lock"), base / "backups"
+    return clone
+
+
+def destination_status(manager, destination, name):
+    dm = destination_manager(manager, destination)
+    path = dm.install_dir / name
+    record = dm._load_state().get(name, {})
+    if not path.exists():
+        status = "Needs attention: files missing" if record else "Not installed"
+    elif path.is_symlink():
+        status = "Needs attention: linked skill (not managed here)"
+    else:
+        valid, _ = dm.validate_skill(path, name)
+        if not valid:
+            status = "Needs attention: invalid skill files"
+        elif not record.get("sha256"):
+            status = "Installed locally (unmanaged)"
+        elif dm._hash_tree(path) != record["sha256"]:
+            status = "Needs attention: files changed"
+        else:
+            status = "Installed locally"
+    if destination.mode == "import" and status.startswith("Installed locally"):
+        archive = path.parent / (path.name + ".zip")
+        exported = record.get("cowork_export", {})
+        current = (archive.is_file() and exported.get("source_sha256") == record.get("sha256")
+                   and exported.get("archive_sha256") == hashlib.sha256(archive.read_bytes()).hexdigest())
+        status = "Import required" if current else "Needs attention: import package missing or stale"
+    return dict(destination=destination.label, status=status, path=str(path), version=record.get("commit", ""), discovery="App discovery unverified")
+
+
+def status_text(manager, name):
+    lines = ["AI app destinations (file placement; app discovery unverified)"]
+    for target in known_destinations(manager, name):
+        row = destination_status(manager, target, name)
+        lines.append(f"{row['destination']}: {row['status']}\n  {row['path']}" + (f"\n  Revision: {row['version'][:12]}" if row['version'] else ""))
+    shared = Path.home() / ".agents" / "skills" / name / "SKILL.md"
+    if shared.is_file():
+        lines.append("Shared .agents/skills copy: also a GitHub Copilot discovery location. Removing it can affect every app using this directory.")
+    return "\n".join(lines)
+
+
+@dataclass
+class DestinationPlan:
+    name: str
+    operation: str
+    scope: tuple
+    groups: list = field(default_factory=list)
+    reviews: dict = field(default_factory=dict)
+
+
+@exclusive_operation
+def review_destinations(manager, name, destinations, operation="install", progress=None):
+    manager.reload()
+    plan = DestinationPlan(name, operation, _scope(manager))
+    dependencies = manager.dependency_plan(name)
+    if dependencies.get("missing"):
+        raise RuntimeError("Missing dependencies: " + ", ".join(dependencies["missing"]))
+    seen = set()
+    for destination in destinations:
+        root = destination.root.expanduser().resolve()
+        # Shared discovery roots are one physical operation.
+        if root in seen:
+            for i, (existing, dm, resolved, batch) in enumerate(plan.groups):
+                if resolved == root:
+                    plan.groups[i] = (replace(existing, label=existing.label + " / " + destination.label), dm, resolved, batch)
+                    break
+            continue
+        seen.add(root)
+        dm = destination_manager(manager, destination)
+        batch = UpdateBatch(_scope(dm), [])
+        plan.groups.append((destination, dm, root, batch))
+        state = dm._load_state()
+        for skill in ([name] if operation == "remove" else dependencies["order"]):
+            spec = dm.get(skill)
+            path = dm.install_dir / skill
+            item = UpdateItem(skill, "FAILED", spec=deepcopy(spec), baseline=deepcopy(state.get(skill)), initial_install=not path.exists())
+            batch.items.append(item)
+            try:
+                if path.is_symlink():
+                    raise RuntimeError("Linked skill is unmanaged here; choose its owning destination.")
+                if path.exists():
+                    if not state.get(skill, {}).get("sha256"):
+                        raise RuntimeError("Existing files are unmanaged. They will not be overwritten or removed.")
+                    item.digest = dm._hash_tree(path)
+                    if item.digest != state[skill]["sha256"]:
+                        raise RuntimeError("Installed files changed. Resolve local edits before continuing.")
+                if operation == "remove":
+                    if not path.exists():
+                        item.status, item.message = "CURRENT", "Not installed at this destination."
+                    elif dm.dependents(skill, installed_only=True):
+                        raise RuntimeError("Other installed skills depend on this skill.")
+                    else:
+                        item.status, item.message = "READY", "Remove this managed copy; other destinations remain unchanged."
+                    continue
+                if path.exists() and (operation == "install" or skill != name):
+                    item.status, item.message = "CURRENT", "Already installed locally."
+                    continue
+                if operation == "update" and skill == name and not path.exists():
+                    raise RuntimeError("Not installed here. Use Install to selected apps first.")
+                if not spec.enabled:
+                    raise RuntimeError("Skill is disabled in the catalog.")
+                if operation == "update" and re.fullmatch(r"[0-9a-fA-F]{7,40}", spec.ref or ""):
+                    raise RuntimeError("Skill is pinned. Unpin it before updating.")
+                if skill not in plan.reviews:
+                    if progress: progress(f"Reviewing source: {skill}…")
+                    plan.reviews[skill] = dm.update_review(spec)
+                item.review = deepcopy(plan.reviews[skill])
+                target = item.review["target_commit"]
+                if not spec.local_path and not re.fullmatch(r"[0-9a-fA-F]{40}", target):
+                    raise RuntimeError("Source did not resolve to an exact commit.")
+                decision = item.review["policy_after"]["decision"]
+                # Destinations never bypass a DENY, even if another destination succeeds.
+                item.status = {"ALLOW": "READY", "REVIEW": "REVIEW"}.get(decision, "BLOCKED")
+                if item.status == "READY" and not spec.trusted and item.review.get("audit_after", {}).get("high", 0):
+                    item.status = "REVIEW"
+                item.message = "Policy: " + decision
+            except Exception as exc:
+                item.status, item.message = "FAILED", str(exc)
+    return plan
+
+
+def _export_cowork(dm, name):
+    source = dm.install_dir / name
+    output = source.parent / (source.name + ".zip")
+    temporary = output.with_suffix(".zip.tmp")
+    files = [p for p in source.rglob("*") if p.is_file()]
+    if any(p.is_symlink() for p in source.rglob("*")):
+        raise RuntimeError("Import package cannot contain symlinks.")
+    if len(files) > 100 or sum(p.stat().st_size for p in files) > 50 * 1024 * 1024:
+        raise RuntimeError("Cowork package exceeds 100 files or 50 MB uncompressed.")
+    try:
+        with zipfile.ZipFile(temporary, "w", zipfile.ZIP_DEFLATED) as archive:
+            for path in files:
+                archive.write(path, path.relative_to(source))
+        if temporary.stat().st_size > 10 * 1024 * 1024:
+            raise RuntimeError("Cowork package exceeds 10 MB compressed.")
+        os.replace(temporary, output)
+        state = dm._load_state()
+        state[name]["cowork_export"] = dict(source_sha256=dm._hash_tree(source), archive_sha256=hashlib.sha256(output.read_bytes()).hexdigest())
+        dm._save_state(state)
+    finally:
+        temporary.unlink(missing_ok=True)
+    return output
+
+
+@exclusive_operation
+def apply_destinations(manager, plan, approved=False, progress=None):
+    if _scope(manager) != plan.scope:
+        raise RuntimeError("Active toolbox changed; review destinations again.")
+    results = []
+    for destination, dm, root, batch in plan.groups:
+        try:
+            if destination.root.expanduser().resolve() != root:
+                raise RuntimeError("Destination link changed; review again.")
+            dm.reload()
+            for item in batch.items:
+                if item.status not in {"READY", "REVIEW"}:
+                    continue
+                if plan.operation == "remove":
+                    path = dm.install_dir / item.name
+                    if path.is_symlink() or dm._hash_tree(path) != item.digest or dm._load_state().get(item.name) != item.baseline or dm.get(item.name) != item.spec:
+                        raise RuntimeError("Files, ownership, or catalog changed; review again.")
+                elif item.review.get("risk_receipt", {}).get("policy") != dm.policy_engine.load():
+                    raise RuntimeError("Policy changed; review again.")
+                elif item.spec.local_path:
+                    from .risk_acknowledgment import validate_receipt
+                    validate_receipt(dm, item.spec, item.review["target_commit"], item.spec.local_path, item.review.get("risk_receipt"))
+            if plan.operation == "remove":
+                rows = []
+                for item in batch.items:
+                    if item.status == "READY":
+                        dm.remove(dm.get(item.name))
+                        if destination.mode == "import":
+                            (dm.install_dir / (item.name + ".zip")).unlink(missing_ok=True)
+                        rows.append(dict(skill=item.name, status="REMOVED", message="Local copy removed."))
+                    else:
+                        rows.append(dict(skill=item.name, status=item.status, message=item.message))
+            else:
+                dm.install_dir.mkdir(parents=True, exist_ok=True)
+                dm.backup_dir.mkdir(parents=True, exist_ok=True)
+                rows = apply_updates(dm, batch, approve_review=approved, progress=progress)
+                for row in rows:
+                    if destination.mode == "import" and row["status"] in {"APPLIED", "CURRENT"}:
+                        try:
+                            output = _export_cowork(dm, row["skill"])
+                            row.update(status="IMPORT REQUIRED", message=f"{output}\nIn Cowork: Customize → Skills → Add → Upload skill. Import each dependency package too. Test in a new conversation. Runtime prerequisites still require review.")
+                        except Exception as exc:
+                            row.update(status="FAILED", message=f"Import package failed: {exc}")
+            for row in rows:
+                row["destination"] = destination.label
+                if destination.mode == "import" and plan.operation == "remove":
+                    row["message"] += " Remove the imported skill separately in Cowork."
+                results.append(row)
+        except Exception as exc:
+            results.append(dict(destination=destination.label, skill=plan.name, status="FAILED", message=str(exc)))
+    return results
+
+
+def format_destination_plan(plan):
+    from .findings_tui import GUIDANCE
+    lines = ["Review selected destinations", "Destinations apply independently. A failed destination does not undo successful changes.",
+             "DENY items remain blocked; REVIEW items require explicit risk approval."]
+    for target, _, _, batch in plan.groups:
+        lines.extend(["", f"{target.label} → {target.root}"])
+        if target.mode == "import":
+            lines.append("Local import package only. Upload it in Cowork; review runtime prerequisites. Copilot Chat is a separate surface.")
+        for item in batch.items:
+            lines.append(f"{item.name}: {item.status} — {item.message}")
+            if item.baseline:
+                lines.append(f"Existing revision: {item.baseline.get('commit', 'unknown')}")
+            if target.host and item.review:
+                evidence = next((r for r in item.review.get("compatibility", []) if r["host"] == target.host), None)
+                if evidence:
+                    lines.append(f"Compatibility: {evidence['format']} / runtime {evidence['runtime']} (static assessment)")
+                    lines.extend(evidence.get("reasons", []))
+    for name, review in plan.reviews.items():
+        lines.extend(["", f"Source review: {name}", f"Exact revision: {review['target_commit']}",
+                      f"Audit: {review['audit_after']}", f"Policy: {review['policy_after']['decision']}"])
+        lines.extend(review['policy_after'].get('reasons', []))
+        for finding in review.get("findings", []):
+            risk, fix = GUIDANCE.get(finding['message'], ('Inspect the source to determine the risk.', 'Review and correct unsafe behavior before use.'))
+            lines.extend([f"{finding['severity']}: {finding['message']} — {finding['path']}", f"Risk: {risk}", f"Suggested fix: {fix}"])
+        lines.extend(review.get("intent_after", {}).get("statements", []))
+        lines.extend(["Source diff against first destination requiring this skill:", review.get("diff", "")])
+    return "\n".join(lines)

skillctl_secure-0.29.0/skillctl/destinations_cli.py

@@ -0,0 +1,67 @@
+"""Explicit multi-destination operations for CLI and automation users."""
+from typing import List, Optional
+import typer
+from rich.table import Table
+from .cli import app, console, manager
+from .destinations import (known_destinations, destination_status, review_destinations,
+                           apply_destinations, format_destination_plan)
+
+
+@app.command("destinations")
+def destinations_cmd(ctx: typer.Context, skill: Optional[str] = typer.Argument(None)):
+    """List AI app destinations, locations, and optional per-skill status."""
+    m = manager(ctx.obj['manifest'])
+    if skill:
+        m.get(skill)
+    table = Table("Target ID", "AI app / toolbox", "Scope", "Location", "Status")
+    for target in known_destinations(m, skill):
+        status = destination_status(m, target, skill)['status'] if skill else ('Import required' if target.mode == 'import' else 'Detected/configured' if target.detected else 'Not detected')
+        from rich.text import Text
+        table.add_row(*(Text(str(v)) for v in (target.id, target.label, target.scope, target.root, status)))
+    console.print(table)
+    console.print('File placement does not confirm app discovery. The active toolbox is independent of AI app destinations.')
+
+
+@app.command("install-to")
+def install_to_cmd(ctx: typer.Context, skill: str, target: List[str] = typer.Option(..., "--target", "-t"),
+                   operation: str = typer.Option("install", "--operation", help="install, update, or remove"),
+                   apply: bool = typer.Option(False, "--apply", help="Apply the displayed destination review."),
+                   approve_review: bool = typer.Option(False, "--approve-review", help="Explicitly approve REVIEW risks; DENY remains blocked.")):
+    """Review installation to one or many destinations; --apply performs it."""
+    if operation not in {'install', 'update', 'remove'}:
+        raise typer.BadParameter('Choose install, update, or remove.', param_hint='--operation')
+    m = manager(ctx.obj['manifest'])
+    options = {d.id: d for d in known_destinations(m, skill)}
+    missing = [key for key in target if key not in options]
+    if missing:
+        raise typer.BadParameter('Unknown destinations: ' + ', '.join(missing), param_hint='--target')
+    plan = review_destinations(m, skill, [options[key] for key in target], operation)
+    console.print(format_destination_plan(plan), markup=False)
+    if not apply:
+        console.print('Review only. Pass --apply to perform the operation.')
+        return
+    rows = apply_destinations(m, plan, approved=approve_review)
+    for row in rows:
+        console.print(f"{row['destination']} · {row['skill']}: {row['status']} — {row['message']}", markup=False)
+    if any(row['status'] in {'FAILED', 'BLOCKED', 'SKIPPED'} for row in rows):
+        raise typer.Exit(1)
+
+
+@app.command("inventory")
+def inventory_cmd(ctx: typer.Context, json_output: bool = typer.Option(False, "--json")):
+    """Discover existing local skills, including skills outside the source catalog."""
+    from .inventory import scan_inventory, inventory_summary
+    from rich.text import Text
+    import json
+    result = scan_inventory(manager(ctx.obj['manifest']))
+    if json_output:
+        typer.echo(json.dumps(result, indent=2))
+        return
+    console.print(inventory_summary(result), markup=False)
+    table = Table("Skill", "Destinations", "Ownership", "Status", "Location")
+    for row in result['rows']:
+        table.add_row(*(Text(value) for value in (row['name'], ', '.join(row['destinations']), row['ownership'], row['state'], row['paths'][0])))
+    console.print(table)
+    for error in result['errors']:
+        console.print(error, markup=False)
+    console.print('Known local directories only. App discovery and content integrity remain unverified.')