code-context-control 2.45.0__py3-none-any.whl → 2.46.0__py3-none-any.whl

cli/c3.py

@@ -85,7 +85,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.45.0"
+__version__ = "2.46.0"
 
 
 def _command_deps() -> CommandDeps:
@@ -239,7 +239,7 @@ _C3_MCP_ALLOW = [
     "mcp__c3__c3_memory", "mcp__c3__c3_validate", "mcp__c3__c3_edit",
     "mcp__c3__c3_agent", "mcp__c3__c3_delegate", "mcp__c3__c3_edits",
     "mcp__c3__c3_impact", "mcp__c3__c3_shell", "mcp__c3__c3_bitbucket",
-    "mcp__c3__c3_project", "mcp__c3__c3_task",
+    "mcp__c3__c3_project", "mcp__c3__c3_task", "mcp__c3__c3_artifacts",
 ]
 
 # Obsolete MCP tool names from earlier C3 versions. `c3 permissions clean`
@@ -4980,6 +4980,11 @@ def cmd_install_mcp(args):
         ) from e
 
     print(f"Wrote {mcp_config_path}")
+    if not profile.config_path_global:
+        # Self-report to the artifact tracker: attribute this write to C3
+        # instead of letting it surface as anonymous out-of-band drift.
+        from services.artifact_defs import note_pending_write
+        note_pending_write(target, profile.config_path, "install_mcp")
     if profile.name in {"codex", "gemini"}:
         _ensure_project_session_configs(target, server_script, primary_profile=profile.name, c3_mcp_exe=c3_mcp_exe)
         _ensure_global_session_fallbacks(server_script, c3_mcp_exe=c3_mcp_exe)
@@ -5181,6 +5186,8 @@ def cmd_install_mcp(args):
             json.dump(settings, f, indent=2)
 
         print(f"Wrote {settings_path}")
+        from services.artifact_defs import note_pending_write
+        note_pending_write(target, profile.settings_path, "install_mcp")
         print(f"  Hooks ({hook_event}): dispatcher (1 spawn/event) — filter/ghost/read-guard/ledger/unlock/signal via cli/hook_dispatch.py posttool")
         print(f"  Hooks ({pre_event}): dispatcher — {read_matcher}/{grep_matcher}/{glob_matcher}/{edit_matcher}/{write_matcher} (c3 enforcement)")
         print("  Hooks (Stop): dispatcher — session_stats + auto_snapshot + terse_advisor")

cli/commands/common.py

@@ -202,7 +202,7 @@ def cmd_claudemd(args, deps: CommandDeps):
             output_path = Path(project_path) / instructions_file
             # Wrap in the C3 managed block; preserve user content outside it.
             from services.claude_md import write_c3_instruction_doc
-            write_c3_instruction_doc(output_path, content)
+            write_c3_instruction_doc(output_path, content, project_path=project_path)
             print(f"{instructions_file} saved to {output_path} ({tokens} tokens)")
 
     elif args.claudemd_cmd == "check":

cli/docs.html

@@ -1148,7 +1148,7 @@ python cli/c3.py install-mcp . gemini</code></pre>
 
       <!-- ─── MCP Tools ───────────────────── -->
       <h2 id="mcp-tools">MCP Tools Reference</h2>
-      <p>C3 exposes 16 MCP tools. All core tools work without Ollama; delegate requires it. The Bitbucket integration is optional and activated via <code>c3 bitbucket login</code>.</p>
+      <p>C3 exposes 18 MCP tools. All core tools work without Ollama; delegate requires it. The Bitbucket integration is optional and activated via <code>c3 bitbucket login</code>.</p>
 
       <h3>Discovery &amp; Compression</h3>
       <table>
@@ -2672,7 +2672,7 @@ c3 session load | claude --resume</code></pre>
   <strong>MCP Proxy</strong> ──── Dynamic tool filtering + context injection (optional, opt-in via MCP config)
        | Subprocess stdio (NDJSON)
        v
-  <strong>C3 MCP Server</strong> ─── 26 tools: search, compress, session, memory, CLAUDE.md, context, hybrid, notifications...
+  <strong>C3 MCP Server</strong> ─── 18 tools: search, compress, session, memory, edits, tasks, artifacts, delegate...
        |
        +── <em>Compression</em>      <em>Smart Index</em>
        |    AST Summary       TF-IDF + Code Structure
@@ -2861,7 +2861,7 @@ c3 session load | claude --resume</code></pre>
       <pre><code>claude-companion/
   cli/
     c3.py                # CLI entry point (all commands)
-    mcp_server.py        # MCP server (30 tools via FastMCP)
+    mcp_server.py        # MCP server (18 tools via FastMCP)
     mcp_proxy.py         # Optional advanced MCP proxy (tool filtering)
     server.py            # Flask web server + REST API
     ui.html              # Single-page React dashboard

cli/guide/index.html

@@ -309,7 +309,7 @@
       <a href="tools.html" class="nav-card">
         <span class="nav-card-icon">🔧</span>
         <div class="nav-card-title">Tools Reference</div>
-        <div class="nav-card-desc">Full reference for all 16 MCP tools — params, examples, notes</div>
+        <div class="nav-card-desc">Full reference for all 18 MCP tools — params, examples, notes</div>
       </a>
       <a href="bitbucket.html" class="nav-card">
         <span class="nav-card-icon">🪣</span>
@@ -509,6 +509,36 @@
             <td><span class="badge badge-yellow">Ledger</span></td>
             <td>Edit ledger: history, versions, audit trail</td>
           </tr>
+          <tr>
+            <td><code>c3_impact</code></td>
+            <td><span class="badge badge-purple">Analysis</span></td>
+            <td>Blast-radius check before editing shared symbols</td>
+          </tr>
+          <tr>
+            <td><code>c3_shell</code></td>
+            <td><span class="badge badge-green">Execute</span></td>
+            <td>Structured shell exec — tests, git, build (auto-filtered)</td>
+          </tr>
+          <tr>
+            <td><code>c3_task</code></td>
+            <td><span class="badge badge-yellow">PM</span></td>
+            <td>Durable tasks, milestones, and decision notes per project</td>
+          </tr>
+          <tr>
+            <td><code>c3_artifacts</code></td>
+            <td><span class="badge badge-yellow">Config</span></td>
+            <td>Agent-config tracking: history, diff &amp; restore for CLAUDE.md, settings, MCP configs, skills</td>
+          </tr>
+          <tr>
+            <td><code>c3_bitbucket</code></td>
+            <td><span class="badge badge-orange">SCM</span></td>
+            <td>Bitbucket Data Center: PRs, branches, builds, repo admin</td>
+          </tr>
+          <tr>
+            <td><code>c3_project</code></td>
+            <td><span class="badge badge-cyan">Multi-project</span></td>
+            <td>Discover &amp; operate on other c3-installed projects</td>
+          </tr>
         </tbody>
       </table>
 

cli/guide/tools.html

@@ -118,6 +118,7 @@
     <div class="sidebar-section">
       <div class="sidebar-label">Ledger</div>
       <a href="#c3_edits"    class="sidebar-link"><span class="icon">📝</span> c3_edits</a>
+      <a href="#c3_artifacts" class="sidebar-link"><span class="icon">🛡️</span> c3_artifacts</a>
     </div>
     <div class="sidebar-section">
       <div class="sidebar-label">SCM</div>
@@ -135,7 +136,7 @@
 
     <div class="page-hero">
       <h1>Tools Reference</h1>
-      <p>Complete reference for all 16 C3 MCP tools — parameters, actions, examples, and usage notes.</p>
+      <p>Complete reference for all 18 C3 MCP tools — parameters, actions, examples, and usage notes.</p>
     </div>
 
     <!-- TOC -->
@@ -157,6 +158,7 @@
         <a href="#c3_agent"    class="toc-item">c3_agent    <span class="cat">AI</span></a>
         <a href="#c3_edits"    class="toc-item">c3_edits    <span class="cat">Ledger</span></a>
         <a href="#c3_task" class="toc-item">c3_task <span class="cat">PM</span></a>
+        <a href="#c3_artifacts" class="toc-item">c3_artifacts <span class="cat">Config</span></a>
         <a href="#c3_bitbucket" class="toc-item">c3_bitbucket <span class="cat">SCM</span></a>
         <a href="#c3_project"  class="toc-item">c3_project  <span class="cat">Multi-project</span></a>
       </div>
@@ -1138,6 +1140,50 @@ c3_task(action=<span class="str">'note_add'</span>, note=<span class="str">'Kanb
         </div>
       </div>
 
+      <!-- c3_artifacts -->
+      <div class="tool-card" id="c3_artifacts">
+        <div class="tool-card-header">
+          <span class="tool-name">c3_artifacts</span>
+          <div class="tag-row">
+            <span class="badge badge-purple">agent config</span>
+            <span class="badge">v2.46.0</span>
+          </div>
+          <span class="tool-tagline">Version history, diff, and restore for the files that shape the agent itself</span>
+        </div>
+        <div class="tool-card-body">
+          <p class="tool-desc">C3 tracks every <em>agent-affecting artifact</em> across all IDEs it knows — instruction docs (<code>CLAUDE.md</code>, <code>AGENTS.md</code>, <code>GEMINI.md</code>, <code>.cursorrules</code>, <code>.github/copilot-instructions.md</code>), settings/hooks (<code>.claude/settings*.json</code>), MCP configs (<code>.mcp.json</code>, <code>.codex/config.toml</code>, <code>.gemini/settings.json</code>, …), and Claude Code extensions (<code>.claude/</code> skills, agents, commands, plugins). Content-addressed snapshots land in <code>.c3/agent_artifacts/</code>; every change is a history event with attribution: <code>c3_edit</code> (this session), <code>hook</code> (native Edit/Write), <code>scan</code> (out-of-band — you edited it in an editor), <code>install_mcp</code> (C3 regenerating its own files), or <code>restore</code>. A background agent scans every ~2 min and warns only when <em>settings or MCP configs</em> change outside C3. Artifact refs accept an id (<code>skill:browcontrol</code>), unique prefix, or plain path (<code>CLAUDE.md</code>). Everything except <code>restore</code> is plan-mode-safe.</p>
+
+          <h4>Actions</h4>
+          <table class="params-table">
+            <thead><tr><th>Action</th><th>Group</th><th>Description</th></tr></thead>
+            <tbody>
+              <tr><td class="param-name">scan</td><td>Read</td><td class="param-desc">Refresh the inventory; captures out-of-band changes immediately (idempotent — unchanged files emit nothing)</td></tr>
+              <tr><td class="param-name">list</td><td>Read</td><td class="param-desc">Inventory with versions; filters: <code>cls</code> (instructions | settings | mcp | skill | agent | command | plugin), <code>provider</code></td></tr>
+              <tr><td class="param-name">history</td><td>Read</td><td class="param-desc">Change events newest-first, with source attribution; <code>artifact</code> optional (all events when omitted)</td></tr>
+              <tr><td class="param-name">show</td><td>Read</td><td class="param-desc">Content at a version (<code>version=0</code> → live file)</td></tr>
+              <tr><td class="param-name">diff</td><td>Read</td><td class="param-desc">Unified diff <code>version</code> → <code>against</code> (omit <code>against</code> to diff vs live)</td></tr>
+              <tr><td class="param-name">restore</td><td>Write</td><td class="param-desc">Write a prior version's exact bytes back. Forward-only (new version + history event, never rewrites), cross-logged to the edit ledger, warns on settings/managed-block files. Resurrects deleted artifacts.</td></tr>
+              <tr><td class="param-name">status</td><td>Read</td><td class="param-desc">Tracked counts by class, out-of-band changes, last scan, pending signals</td></tr>
+            </tbody>
+          </table>
+
+          <h4>Examples</h4>
+          <pre><code><span class="com"># What changed behind my back?</span>
+c3_artifacts(action=<span class="str">'status'</span>)
+c3_artifacts(action=<span class="str">'history'</span>, limit=<span class="num">10</span>)
+
+<span class="com"># Someone (or something) touched the hooks — inspect and roll back</span>
+c3_artifacts(action=<span class="str">'diff'</span>, artifact=<span class="str">'.claude/settings.local.json'</span>, version=<span class="num">3</span>)
+c3_artifacts(action=<span class="str">'restore'</span>, artifact=<span class="str">'settings:.claude/settings.local.json'</span>, version=<span class="num">3</span>)
+
+<span class="com"># Track a skill's evolution</span>
+c3_artifacts(action=<span class="str">'history'</span>, artifact=<span class="str">'skill:browcontrol'</span>)
+c3_artifacts(action=<span class="str">'show'</span>, artifact=<span class="str">'skill:browcontrol'</span>, version=<span class="num">2</span>)</code></pre>
+
+          <p class="tool-desc"><strong>Surfaces:</strong> the Hub drill-in panel gets an Artifacts tab (class-grouped inventory, per-version timeline, diff viewer, two-step restore); REST at <code>/api/artifacts*</code> per project and <code>/api/projects/artifacts*</code> on the hub. Changes made through <code>c3_edit</code> and <code>install-mcp</code> self-attribute — only genuinely foreign edits show as <code>scan</code>. Disable with <code>hybrid.agent_artifacts.enabled=false</code>.</p>
+        </div>
+      </div>
+
       <!-- c3_bitbucket -->
       <div class="tool-card" id="c3_bitbucket">
         <div class="tool-card-header">

cli/hook_artifact.py

@@ -0,0 +1,67 @@
+"""PostToolUse hook: signal agent-artifact writes for attributed capture.
+
+Fires alongside the edit ledger on Edit/Write/NotebookEdit. When the touched
+file classifies as an agent-affecting artifact (instruction docs, settings/
+hooks, MCP configs, .claude skills/agents/commands — see
+services/artifact_defs), appends a one-line pending signal to
+.c3/agent_artifacts/pending.jsonl.
+
+Performance: no hashing, no manifest lock — the ArtifactScanAgent consumes
+signals asynchronously and attributes the resulting history events to
+source='hook'. Silent hook: never emits user-visible output.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+# Add project root to path for imports
+_project_root = str(Path(__file__).resolve().parent.parent)
+if _project_root not in sys.path:
+    sys.path.insert(0, _project_root)
+
+from cli._hook_utils import get_tool_input_path, log_hook_error, normalize_tool_name  # noqa: E402
+from services.artifact_defs import classify_path, note_pending_write  # noqa: E402
+
+
+def run(payload: dict, project_path: Path | None = None) -> None:
+    """Core logic — importable by the dispatcher and tests. Always None."""
+    tool_name = normalize_tool_name(payload.get("tool_name", ""))
+    if tool_name not in ("Edit", "Write", "NotebookEdit"):
+        return None
+
+    file_path = get_tool_input_path(payload)
+    if not file_path:
+        return None
+
+    if project_path is None:
+        project_path = Path.cwd()
+    if not (project_path / ".c3").exists():
+        return None  # Not a C3 project
+
+    try:
+        rel = str(Path(file_path).resolve().relative_to(project_path.resolve()))
+    except (ValueError, OSError):
+        return None  # outside the project → not a project artifact
+
+    if classify_path(rel) is None:
+        return None
+
+    note_pending_write(project_path, rel, "hook",
+                       session_id=payload.get("session_id", "") or "",
+                       tool=tool_name)
+    return None
+
+
+def main():
+    try:
+        raw = sys.stdin.read()
+        if not raw.strip():
+            return
+        run(json.loads(raw))
+    except Exception as _e:
+        log_hook_error("hook_artifact", _e)
+
+
+if __name__ == "__main__":
+    main()

cli/hook_dispatch.py

@@ -96,6 +96,7 @@ def _routes(event: str, raw_tool: str, norm_tool: str):
             yield "hook_c3_signal"
         if norm_tool in _LEDGER_TOOLS:
             yield "hook_edit_ledger"
+            yield "hook_artifact"
         if raw_tool in _GHOST_TOOLS:
             yield "hook_ghost_files"
     elif event == "stop":

cli/hub_server.py

@@ -335,6 +335,7 @@ _HUB_JS_FILES = [
     "hub_ui/components/drill_views.js",
     "hub_ui/components/drill_health.js",
     "hub_ui/components/drill_tasks.js",
+    "hub_ui/components/drill_artifacts.js",
     "hub_ui/components/config_editor.js",
     "hub_ui/components/mcp_manager.js",
     "hub_ui/components/global_search.js",
@@ -1892,6 +1893,99 @@ def api_pm_link():
     return jsonify({"task": res})
 
 
+# ── Agent artifacts: config tracking (v2.46.0) ────────────────────────────
+# Direct ArtifactStore per request (load-per-op store — no runtime build
+# needed); every mutation audited to the target project's activity log.
+
+def _artifact_store_for(path):
+    from services.artifact_store import ArtifactStore
+    return ArtifactStore(str(path))
+
+
+def _artifact_audit(path, op, ref=""):
+    try:
+        ActivityLog(str(path)).log("artifact_write", {
+            "op": op, "ref": ref, "source": "hub"})
+    except Exception:
+        pass
+
+
+@app.route("/api/projects/artifacts", methods=["GET"])
+def api_projects_artifacts():
+    """Artifact inventory + tracker status. Query: path, cls?, provider?"""
+    resolved, err = _pm_resolve((request.args.get("path") or "").strip())
+    if err:
+        return err
+    store = _artifact_store_for(resolved)
+    return jsonify({
+        "path": str(resolved),
+        "artifacts": store.list_artifacts(
+            cls=request.args.get("cls", ""),
+            provider=request.args.get("provider", "")),
+        "status": store.status(),
+    })
+
+
+@app.route("/api/projects/artifacts/history", methods=["GET"])
+def api_projects_artifacts_history():
+    """History events, newest first. Query: path, artifact?, limit?"""
+    resolved, err = _pm_resolve((request.args.get("path") or "").strip())
+    if err:
+        return err
+    try:
+        limit = max(1, min(int(request.args.get("limit") or 50), 500))
+    except (TypeError, ValueError):
+        limit = 50
+    return jsonify({"events": _artifact_store_for(resolved).get_history(
+        artifact=request.args.get("artifact", ""), limit=limit)})
+
+
+@app.route("/api/projects/artifacts/scan", methods=["POST"])
+def api_projects_artifacts_scan():
+    data = request.get_json(force=True) or {}
+    resolved, err = _pm_resolve((data.get("path") or "").strip())
+    if err:
+        return err
+    store = _artifact_store_for(resolved)
+    store.consume_pending()
+    res = store.scan()
+    res.pop("events", None)  # event dicts live on the history endpoint
+    _artifact_audit(resolved, "scan")
+    return jsonify(res)
+
+
+@app.route("/api/projects/artifacts/diff", methods=["POST"])
+def api_projects_artifacts_diff():
+    data = request.get_json(force=True) or {}
+    resolved, err = _pm_resolve((data.get("path") or "").strip())
+    if err:
+        return err
+    if not data.get("artifact") or not data.get("version"):
+        return jsonify({"error": "artifact and version are required"}), 400
+    res = _artifact_store_for(resolved).diff(
+        data["artifact"], int(data["version"]),
+        int(data["against"]) if data.get("against") else None)
+    if "error" in res:
+        return jsonify(res), 400
+    return jsonify(res)
+
+
+@app.route("/api/projects/artifacts/restore", methods=["POST"])
+def api_projects_artifacts_restore():
+    data = request.get_json(force=True) or {}
+    resolved, err = _pm_resolve((data.get("path") or "").strip())
+    if err:
+        return err
+    if not data.get("artifact") or not data.get("version"):
+        return jsonify({"error": "artifact and version are required"}), 400
+    res = _artifact_store_for(resolved).restore(
+        data["artifact"], int(data["version"]), session_id="hub")
+    if "error" in res:
+        return jsonify(res), 400
+    _artifact_audit(resolved, "restore", f"{res['id']}@v{data['version']}")
+    return jsonify(res)
+
+
 @app.route("/api/pm/global", methods=["GET"])
 def api_pm_global():
     """Open tasks across every registered project (raw registry — no port probes)."""

cli/hub_ui/components/drill_artifacts.js

@@ -0,0 +1,218 @@
+// ─── Drill panel: Artifacts tab (agent-config tracking) ────────
+// Inventory of agent-affecting files (instruction docs, settings/hooks,
+// MCP configs, .claude skills/agents/commands) with version history,
+// diff viewer and restore. Reads GET /api/projects/artifacts?path=…;
+// history via /api/projects/artifacts/history; scan/diff/restore POST
+// to the matching hub endpoints. A 409 renders DrillNeedsInit.
+
+const ARTIFACT_CLASS_LABELS = {
+  instructions: 'Instructions', settings: 'Settings', mcp: 'MCP config',
+  skill: 'Skills', agent: 'Agents', command: 'Commands', plugin: 'Plugins',
+};
+
+function artifactClassColor(cls) {
+  return ({
+    instructions: T.blue, settings: T.warn, mcp: T.purple,
+    skill: T.accent, agent: T.blue, command: T.warn, plugin: T.purple,
+  })[cls] || T.textMuted;
+}
+
+function DrillArtifactHistory({ project, art, onChanged }) {
+  const [events, setEvents] = useState(null);
+  const [diff, setDiff] = useState(null);        // {label, text}
+  const [confirmV, setConfirmV] = useState(null); // version pending confirm
+  const [warnings, setWarnings] = useState([]);
+
+  const load = async () => {
+    try {
+      const d = await api.get('/api/projects/artifacts/history?path='
+        + encodeURIComponent(project.path)
+        + '&artifact=' + encodeURIComponent(art.id) + '&limit=30');
+      setEvents(d.events || []);
+    } catch (e) { notify('History failed: ' + e.message, 'err'); }
+  };
+  useEffect(() => { load(); }, [art.id]);
+
+  const showDiff = async (v, against) => {
+    try {
+      const body = { path: project.path, artifact: art.id, version: v };
+      if (against) body.against = against;
+      const d = await api.post('/api/projects/artifacts/diff', body);
+      setDiff({ label: `${d.from} → ${d.to}  (+${d.plus} −${d.minus})`, text: d.diff });
+    } catch (e) { notify('Diff failed: ' + e.message, 'err'); }
+  };
+
+  const restore = async (v) => {
+    if (confirmV !== v) { setConfirmV(v); setTimeout(() => setConfirmV(null), 4000); return; }
+    setConfirmV(null);
+    try {
+      const d = await api.post('/api/projects/artifacts/restore',
+        { path: project.path, artifact: art.id, version: v });
+      notify(`Restored ${d.id} v${v} → live as v${d.new_version}`, 'ok');
+      setWarnings(d.warnings || []);
+      setDiff(null);
+      load();
+      if (onChanged) onChanged();
+    } catch (e) { notify('Restore failed: ' + e.message, 'err'); }
+  };
+
+  if (events === null) return <DrillMsg text="Loading history…" />;
+  if (!events.length) return <DrillMsg text="No recorded events yet." />;
+
+  return (
+    <div style={{ padding: '6px 0 10px 22px' }}>
+      {warnings.map((w, i) => (
+        <div key={i} style={{
+          fontSize: 11, color: T.warn, padding: '3px 0', lineHeight: 1.4,
+        }}>⚠ {w}</div>
+      ))}
+      {events.map(ev => (
+        <div key={ev.id} style={{
+          display: 'flex', alignItems: 'center', gap: 8, padding: '5px 0',
+          borderBottom: `1px solid ${T.border}`, minWidth: 0,
+        }}>
+          <span className="mono" style={{ fontSize: 11, color: T.text, flexShrink: 0 }}>
+            v{ev.version}
+          </span>
+          <Badge color={ev.event === 'deleted' ? T.error
+            : ev.event === 'restored' ? T.accent : T.blue}>{ev.event}</Badge>
+          <Badge color={ev.source === 'scan' ? T.warn : T.textMuted}>{ev.source}</Badge>
+          <span title={ev.summary || ''} style={{
+            fontSize: 11, color: T.textMuted, flex: 1, minWidth: 0,
+            whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis',
+          }}>{(ev.ts || '').replace('T', ' ')}{ev.summary ? ' — ' + ev.summary : ''}</span>
+          {ev.event !== 'deleted' && (
+            <React.Fragment>
+              <button onClick={() => showDiff(ev.version)} title="Diff this version vs live"
+                style={{ background: 'none', border: 'none', cursor: 'pointer',
+                         color: T.blue, fontSize: 11, padding: '2px 4px', flexShrink: 0 }}>
+                diff
+              </button>
+              <button onClick={() => restore(ev.version)} title="Restore this version"
+                style={{ background: 'none', border: 'none', cursor: 'pointer',
+                         color: confirmV === ev.version ? T.error : T.warn,
+                         fontSize: 11, fontWeight: confirmV === ev.version ? 700 : 400,
+                         padding: '2px 4px', flexShrink: 0 }}>
+                {confirmV === ev.version ? 'confirm?' : 'restore'}
+              </button>
+            </React.Fragment>
+          )}
+        </div>
+      ))}
+      {diff && (
+        <div style={{ marginTop: 10 }}>
+          <div style={{ fontSize: 11, color: T.textMuted, marginBottom: 4 }}>
+            {diff.label}
+            <button onClick={() => setDiff(null)} style={{
+              background: 'none', border: 'none', cursor: 'pointer',
+              color: T.textDim, fontSize: 11, marginLeft: 8 }}>× close</button>
+          </div>
+          <pre className="mono" style={{
+            background: T.surfaceAlt, border: `1px solid ${T.border}`, borderRadius: 6,
+            padding: 10, fontSize: 11, lineHeight: 1.5, overflow: 'auto',
+            maxHeight: 320, whiteSpace: 'pre-wrap', color: T.text, margin: 0,
+          }}>{diff.text}</pre>
+        </div>
+      )}
+    </div>
+  );
+}
+
+function DrillArtifacts({ project, onChanged }) {
+  const [data, setData] = useState(null);
+  const [err, setErr] = useState(null);
+  const [needsInit, setNeedsInit] = useState(false);
+  const [openId, setOpenId] = useState(null);
+  const [scanning, setScanning] = useState(false);
+
+  const load = async () => {
+    setErr(null);
+    try {
+      const d = await api.get('/api/projects/artifacts?path='
+        + encodeURIComponent(project.path));
+      setData(d);
+      setNeedsInit(false);
+    } catch (e) {
+      if (e.status === 409) setNeedsInit(true);
+      else setErr(e.message);
+    }
+  };
+  useEffect(() => {
+    setData(null); setNeedsInit(false); setOpenId(null);
+    load();
+  }, [project.path]);
+
+  const scan = async () => {
+    if (scanning) return;
+    setScanning(true);
+    try {
+      const d = await api.post('/api/projects/artifacts/scan', { path: project.path });
+      notify(`Scan: ${d.added.length} added, ${d.modified.length} modified, `
+        + `${d.deleted.length} deleted`, 'ok');
+      load();
+      if (onChanged) onChanged();
+    } catch (e) { notify('Scan failed: ' + e.message, 'err'); }
+    setScanning(false);
+  };
+
+  if (needsInit) return <DrillNeedsInit project={project} onReady={load} />;
+  if (err) return <DrillMsg text={err} color={T.error} />;
+  if (!data) return <DrillMsg text="Loading artifacts…" />;
+
+  const arts = data.artifacts || [];
+  const st = data.status || {};
+  const byClass = {};
+  arts.forEach(a => { (byClass[a.class] = byClass[a.class] || []).push(a); });
+
+  return (
+    <div>
+      <div style={{ display: 'flex', alignItems: 'center', gap: 10, marginBottom: 4 }}>
+        <span style={{ fontSize: 12, color: T.textMuted, flex: 1 }}>
+          {st.tracked || 0} tracked · {st.out_of_band_recent || 0} recent out-of-band
+          {st.last_scan ? ` · last scan ${String(st.last_scan).replace('T', ' ')}` : ''}
+        </span>
+        <Btn onClick={scan} disabled={scanning}>{scanning ? 'Scanning…' : 'Scan now'}</Btn>
+      </div>
+      {!arts.length && (
+        <DrillMsg text="Nothing tracked yet — run a scan to build the inventory." />
+      )}
+      {Object.keys(ARTIFACT_CLASS_LABELS).filter(c => byClass[c]).map(cls => (
+        <DrillSection key={cls} label={ARTIFACT_CLASS_LABELS[cls]} style={{ marginTop: 18 }}>
+          {byClass[cls].map(a => (
+            <div key={a.id}>
+              <div onClick={() => setOpenId(openId === a.id ? null : a.id)} style={{
+                display: 'flex', alignItems: 'center', gap: 8, padding: '7px 0',
+                borderBottom: `1px solid ${T.border}`, cursor: 'pointer', minWidth: 0,
+              }}>
+                <span style={{
+                  width: 7, height: 7, borderRadius: '50%', flexShrink: 0,
+                  background: artifactClassColor(a.class),
+                  opacity: a.exists ? 1 : 0.35,
+                }} />
+                <span className="mono" title={a.root} style={{
+                  fontSize: 12, color: a.exists ? T.text : T.textDim, flex: 1, minWidth: 0,
+                  whiteSpace: 'nowrap', overflow: 'hidden', textOverflow: 'ellipsis',
+                  textDecoration: a.exists ? 'none' : 'line-through',
+                }}>{a.id}</span>
+                {!a.exists && <Badge color={T.error}>deleted</Badge>}
+                {(a.roles || []).map(r => <Badge key={r} color={T.textMuted}>{r}</Badge>)}
+                <span className="mono" style={{ fontSize: 11, color: T.textMuted, flexShrink: 0 }}>
+                  v{a.version}
+                </span>
+                <span style={{ fontSize: 11, color: T.textDim, flexShrink: 0 }}>
+                  {a.files} file{a.files === 1 ? '' : 's'}
+                </span>
+                <span className="mono" style={{ fontSize: 10, color: T.textDim, flexShrink: 0 }}>
+                  {(a.last_changed || '').slice(0, 10)}
+                </span>
+              </div>
+              {openId === a.id && (
+                <DrillArtifactHistory project={project} art={a} onChanged={onChanged} />
+              )}
+            </div>
+          ))}
+        </DrillSection>
+      ))}
+    </div>
+  );
+}

cli/hub_ui/components/drill_panel.js

@@ -6,6 +6,7 @@
 const DRILL_PANEL_TABS = [
   ['overview', 'Overview'],
   ['tasks', 'Tasks'],
+  ['artifacts', 'Artifacts'],
   ['memory', 'Memory'],
   ['ledger', 'Ledger'],
   ['sessions', 'Sessions'],
@@ -109,6 +110,7 @@ function DrillPanel({ project, tab, setTab, onClose, onChanged, onOpenModal }) {
   const renderTab = () => {
     switch (tab) {
       case 'tasks': return <DrillTasks project={project} onChanged={onChanged} />;
+      case 'artifacts': return <DrillArtifacts project={project} onChanged={onChanged} />;
       case 'memory': return <DrillMemory project={project} />;
       case 'ledger': return <DrillLedger project={project} />;
       case 'sessions': return <DrillSessions project={project} />;