agentrinse 0.3.0 → 0.5.0

package/README.md

@@ -1,147 +1,273 @@
-# AgentRinse
-
-Safe, local-first cleanup for agentic development.
-
-AgentRinse inventories agent state and developer residue, explains why each
-resource is protected or eligible, creates content-addressed cleanup plans,
-and applies only actions that still pass every safety check.
-
-Version `0.3.0` adds recoverable quarantine for fully proven inactive linked
-Git worktrees. Quarantine is opt-in at the `recoverable` risk ceiling, keeps a
-tested undo path, and reports zero immediate disk reclaim until a separate
-purge. Exact configured rebuildable artifacts remain the only `safe` action.
-Provider state, runtimes, and Docker resources remain report-only.
-
-## Install
+# agentrinse 🫧
+
+audit first. clean deliberately. recover when it matters.
+
+## what is agentrinse?
+
+agentrinse is a local-first cleanup planner for machines where coding agents,
+worktrees, build artifacts, runtimes, and Docker state accumulate faster than
+humans can safely reason about them.
+
+it does not treat "old", "large", or "missing from the current terminal" as
+proof that something is disposable. agentrinse inventories the machine,
+reconstructs ownership and reachability, explains why every resource is
+protected or eligible, creates a content-addressed plan, and revalidates the
+same facts immediately before mutation.
+
+agentrinse is not audit-only. audit establishes the evidence; apply performs
+the approved filesystem, Git metadata, and offline database changes. `0.5.0`
+removes exact configured rebuildable artifacts, quarantines proven inactive
+linked worktrees, repairs and locks their Git registrations, restores
+quarantined worktrees, permanently purges explicitly selected quarantine
+entries, and compacts supported Codex SQLite state with a retained rollback
+copy. It also quarantines exact stale Claude debug logs and changelog cache
+files with a seven-day undo window.
+
+the point is confidence: make real cleanup changes without deleting the
+session, branch, worktree, database content, or cache that another agent still
+needs.
+unknown state fails closed and recoverable worktrees are quarantined before
+they can be purged.
+
+agentrinse is deliberately not another generic disk cleaner. it understands
+agent and Git ownership; [Mole](https://github.com/tw93/Mole) remains an
+optional external handoff for broader macOS and project debris.
+
+## cleanup actions
+
+| Action                 | Risk         | What changes                                                                   | Recovery                                |
+| ---------------------- | ------------ | ------------------------------------------------------------------------------ | --------------------------------------- |
+| 🧹 artifact removal    | safe         | atomically isolates and removes an exact configured rebuildable directory      | rebuild from the project                |
+| 🌿 worktree quarantine | recoverable  | moves a linked worktree, creates a recovery ref, and repairs Git registration  | `agentrinse undo <run-id>`              |
+| 🧾 provider quarantine | recoverable  | moves an exact provider-owned disposable file into private recovery storage    | `agentrinse undo <run-id>`              |
+| 🗜️ Codex DB vacuum     | experimental | builds and verifies a compacted SQLite copy, then retains the original file    | `agentrinse undo <run-id>` before reuse |
+| ↩️ recovery undo       | recoverable  | restores a quarantined worktree, provider file, or database original           | recovery remains journaled              |
+| 🗑️ recovery purge      | destructive  | permanently removes an explicitly selected worktree, provider file, or DB copy | none                                    |
+| ⚙️ config init         | operational  | creates the default config without overwriting an existing file                | edit or remove the generated config     |
+| 🔒 lock recovery       | operational  | removes only a stale AgentRinse lock after proving its process is gone         | rerun the interrupted command           |
+
+provider sessions, transcripts, credentials, configuration, and logical
+database records remain report-only. `0.5.0` supports explicit offline
+compaction for the exact current Codex `state_5`, `logs_2`, `goals_1`, and
+`memories_1` SQLite contracts. Claude cleanup is limited to exact old debug
+text files and its rebuildable changelog cache. AgentRinse also reports
+Claude's native retention policy and Copilot's native session and process-log
+maintenance. Docker remains audit-only.
+
+## agent integrations
+
+provider state is report-only unless the table below says otherwise.
+agentrinse never erases transcripts, sessions, credentials, configuration, or
+logical memory records.
+
+| Logo                                                                        | Client                                                      | Mode                    | What it protects                                                    |
+| --------------------------------------------------------------------------- | ----------------------------------------------------------- | ----------------------- | ------------------------------------------------------------------- |
+| <img width="48px" src="docs/client-openai.jpg" alt="OpenAI Codex" />        | [OpenAI Codex](https://github.com/openai/codex)             | audit + offline vacuum  | sessions, workspace roots, reachability, and supported SQLite state |
+| <img width="48px" src="docs/client-claude.jpg" alt="Claude Code" />         | [Claude Code](https://code.claude.com/docs/en/overview)     | retention + quarantine  | sessions, caches, roots, native retention, and exact old files      |
+| <img width="48px" src="docs/client-cursor.jpg" alt="Cursor" />              | [Cursor](https://cursor.com/docs)                           | audit-only              | local agent state and workspace references                          |
+| <img width="48px" src="docs/client-copilot.png" alt="GitHub Copilot CLI" /> | [GitHub Copilot CLI](https://github.com/github/copilot-cli) | audit + native guidance | local sessions, process logs, and provider-owned maintenance        |
+| <img width="48px" src="docs/client-zed.svg" alt="Zed" />                    | [Zed](https://zed.dev/docs/ai/overview)                     | audit-only              | local agent state                                                   |
+| <img width="48px" src="docs/client-opencode.png" alt="OpenCode" />          | [OpenCode](https://opencode.ai/)                            | audit-only              | local agent state                                                   |
+| <img width="48px" src="docs/client-grok-build.svg" alt="Grok Build" />      | [Grok Build](https://docs.x.ai/build/overview)              | audit-only              | local agent state                                                   |
+
+## cleanup surfaces
+
+| Icon                                                                        | Surface                              | Mode               | What it understands                                                     |
+| --------------------------------------------------------------------------- | ------------------------------------ | ------------------ | ----------------------------------------------------------------------- |
+| 🌿                                                                          | Git worktrees                        | audit + quarantine | linked worktrees, refs, dirtiness, locks, processes, and provider roots |
+| 🧹                                                                          | Build artifacts                      | safe-clean         | exact configured rebuildable directories                                |
+| 🗜️                                                                          | Codex SQLite state                   | experimental       | schema versions, free pages, sidecars, owner processes, and rollback    |
+| <img width="48px" src="docs/client-claude.jpg" alt="Claude Code" />         | Claude native retention              | report-only        | default or user retention, settings validity, and provider ownership    |
+| <img width="48px" src="docs/client-claude.jpg" alt="Claude Code" />         | Claude logs and changelog cache      | recoverable        | exact old files, provider liveness, seven-day undo, and explicit purge  |
+| <img width="48px" src="docs/client-copilot.png" alt="GitHub Copilot CLI" /> | Copilot native maintenance           | report-only        | local session pruning and versioned process-log retention               |
+| ⚡                                                                          | Agent runtimes                       | audit-only, opt-in | installed agent executables and versions                                |
+| <img width="48px" src="docs/client-docker-agent.svg" alt="Docker" />        | [Docker](https://docs.docker.com/)   | audit-only, opt-in | images and containers                                                   |
+| 🕳️                                                                          | [Mole](https://github.com/tw93/Mole) | suggestions only   | external dry-run cleanup opportunities on macOS                         |
+
+## install
 
 Node.js 22 or newer is required.
 
 ```bash
-npm install --global agentrinse
-agentrinse --version
+npm install -g agentrinse
+# or
+pnpm add -g agentrinse
+# or
+yarn global add agentrinse
+# or
+brew install vincentkoc/tap/agentrinse
 ```
 
-Homebrew:
+one-off use:
 
 ```bash
-brew install vincentkoc/tap/agentrinse
+npx agentrinse@0.5.0 doctor
 ```
 
-One-off use also works:
+then:
 
 ```bash
-npx agentrinse@0.3.0 doctor
+agentrinse --version
+agentrinse doctor
+agentrinse adapters
 ```
 
-## Quickstart
+## quick rinse
 
-Create a default configuration without overwriting an existing file:
+from a Git worktree, inspect repository-scoped agent residue:
 
 ```bash
-agentrinse config init
-agentrinse config path
+agentrinse clean --profile closeout
 ```
 
-Edit the generated JSON and add explicit artifact roots:
-
-```json
-{
-  "schemaVersion": 1,
-  "artifacts": {
-    "projects": [
-      {
-        "root": "/absolute/path/to/project",
-        "names": ["node_modules", "dist", ".cache"]
-      }
-    ],
-    "minAgeMinutes": 1440,
-    "minBytes": 67108864,
-    "processCheck": "required"
-  },
-  "worktrees": {
-    "minAgeMinutes": 20160,
-    "quarantineTtlMinutes": 10080
-  },
-  "plan": {
-    "ttlMinutes": 30,
-    "maxRisk": "safe"
-  }
-}
-```
+this audits the current repository, its linked worktrees, and relevant Codex
+and Claude reachability metadata. the current worktree is always protected.
+the command creates a plan but does not infer that your task is finished and
+does not mutate anything unless `--apply` is present.
 
-Run diagnostics before the first audit:
+apply only reviewed `safe` artifact actions:
 
 ```bash
-agentrinse config validate
-agentrinse doctor
+agentrinse clean --profile closeout --apply
 ```
 
-Audit and save exact evidence:
+automation must authorize explicitly:
 
 ```bash
-agentrinse audit --home "$HOME" --output audit.json
+agentrinse clean --profile closeout --apply --yes --max-risk safe --json
 ```
 
-Create and review a bounded plan:
+whole-worktree cleanup is recoverable and must be selected separately:
 
 ```bash
-agentrinse plan --audit audit.json --output plan.json
-cat plan.json
+agentrinse clean --profile closeout --max-risk recoverable
+agentrinse clean --profile closeout --max-risk recoverable --apply --yes
 ```
 
-Apply only after reviewing the plan:
+that moves a proven inactive linked worktree into quarantine. it does not
+reclaim disk immediately. restore it or inspect a later permanent purge:
 
 ```bash
-agentrinse apply --plan plan.json
+agentrinse undo <run-id>
+agentrinse purge --run <run-id>
+agentrinse purge --run <run-id> --apply --yes
 ```
 
-Interactive apply asks for confirmation. Automation must pass `--yes`.
-
-## Agent Closeout
-
-From a Git worktree, create a repository-scoped audit and plan:
+offline Codex database compaction is a separate experimental workflow. quit
+every Codex CLI and desktop process first:
 
 ```bash
-agentrinse clean --profile closeout
+agentrinse audit --allow-offline-vacuum --output audit.json
+agentrinse plan --audit audit.json --max-risk experimental --output plan.json
+agentrinse apply --plan plan.json --max-risk experimental --yes
 ```
 
-The current worktree is always protected. The profile inventories its
-repository's linked worktrees, loads Codex and Claude reachability metadata,
-and ignores unrelated configured artifact projects. It does not infer that a
-task is finished.
-
-After reviewing the summary, a fresh closeout can apply existing `safe`
-artifact actions:
+only databases with at least 512 MiB and 25 percent free pages are proposed.
+apply holds exclusive SQLite-compatible file locks across an atomic path
+exchange, so Codex cannot reopen either inode during installation. the original
+file is retained for seven days. undo uses the same locked exchange and refuses
+after Codex has reopened or changed the compacted database:
 
 ```bash
-agentrinse clean --profile closeout --apply
-agentrinse clean --profile closeout --apply --yes --max-risk safe --json
+agentrinse undo <run-id>
+agentrinse purge --expired
+agentrinse purge --expired --apply --yes
 ```
 
-Whole-worktree quarantine must be selected explicitly:
+apply reports zero reclaimed bytes while the original remains retained. run
+journals record `retainedBackupBytes`; purge reports bytes only when that
+rollback set is actually deleted.
+
+## commands
+
+| Command                                   | Purpose                                                   | Mutation              |
+| ----------------------------------------- | --------------------------------------------------------- | --------------------- |
+| `agentrinse audit`                        | inventory a home and explain protection evidence          | none                  |
+| `agentrinse audit --allow-offline-vacuum` | propose supported offline Codex DB actions                | none                  |
+| `agentrinse plan`                         | create a bounded plan from a saved audit                  | persisted plan only   |
+| `agentrinse clean --profile closeout`     | audit and plan the current repository                     | none                  |
+| `agentrinse apply --plan <file>`          | revalidate and apply an authorized plan                   | selected actions      |
+| `agentrinse undo <run-id>`                | restore recoverable actions from a run                    | recovery restore      |
+| `agentrinse purge`                        | preview worktree and database recovery backups            | none                  |
+| `agentrinse purge --apply --yes`          | permanently remove selected recovery backups              | destructive           |
+| `agentrinse doctor`                       | diagnose platform, config, state, Git, and optional tools | none                  |
+| `agentrinse adapters`                     | show adapter maturity and ownership                       | none                  |
+| `agentrinse history`                      | list persisted cleanup runs                               | none                  |
+| `agentrinse show`                         | inspect runs, plans, and resource findings                | none                  |
+| `agentrinse lock status`                  | inspect the global apply lock                             | none                  |
+| `agentrinse lock recover --yes`           | remove a stale lock after process proof                   | stale lock only       |
+| `agentrinse config`                       | locate, initialize, show, or validate configuration       | `init` creates a file |
+| `agentrinse completion <shell>`           | generate bash, zsh, or fish completion                    | none                  |
+
+run `agentrinse <command> --help` for the complete option set.
+
+## safety model
+
+agentrinse is built around refusal:
+
+1. **discover** resources through owner APIs and structured state where
+   possible.
+2. **protect** anything active, reachable, dirty, pinned, provider-managed, or
+   unknown.
+3. **plan** exact actions against canonical paths and measured identities.
+4. **authorize** with an expiring, content-addressed plan and explicit risk
+   ceiling.
+5. **revalidate** paths, processes, refs, metadata, age, size, and provider
+   roots under the mutation lock.
+6. **isolate** the exact target with an atomic same-filesystem rename before
+   removal.
+7. **journal** every transition so interrupted work can be inspected,
+   recovered, or undone.
+
+there is no generic `--force` escape hatch.
+
+agentrinse `0.5.0` never removes:
+
+- provider sessions, transcripts, logical database rows, credentials, or configuration
+- unsupported provider databases or Codex databases with unknown migrations
+- plugins, skills, memories, or agent instruction files
+- Git branches, stashes, the main worktree, or the current worktree
+- Docker images, containers, networks, volumes, or build cache
+- sockets, pipes, devices, mounts, or symlink targets
+
+### build artifacts
+
+direct removal is limited to exact names under explicitly configured project
+roots:
 
 ```bash
-agentrinse clean --profile closeout --max-risk recoverable
-agentrinse clean --profile closeout --max-risk recoverable --apply --yes
+agentrinse config init
+agentrinse config path
 ```
 
-Quarantine moves bytes out of the active path but does not reclaim disk.
-Restore or permanently purge the resulting run:
+edit the generated JSON and add explicit artifact roots:
 
-```bash
-agentrinse undo <run-id>
-agentrinse purge --run <run-id>
-agentrinse purge --run <run-id> --apply --yes
+```json
+{
+  "schemaVersion": 1,
+  "artifacts": {
+    "projects": [
+      {
+        "root": "/absolute/path/to/project",
+        "names": ["node_modules", "dist", ".cache"]
+      }
+    ],
+    "minAgeMinutes": 1440,
+    "minBytes": 67108864,
+    "processCheck": "required"
+  },
+  "worktrees": {
+    "minAgeMinutes": 20160,
+    "quarantineTtlMinutes": 10080
+  },
+  "plan": {
+    "ttlMinutes": 30,
+    "maxRisk": "safe"
+  }
+}
 ```
 
-On macOS, an installed Mole binary adds external `mo purge --dry-run` and
-`mo clean --dry-run` suggestions. AgentRinse never runs those commands.
-
-## Mutation Boundary
-
-AgentRinse has two mutation classes.
-
-`safe` artifact removal supports only these configured names:
+supported artifact names:
 
 - `node_modules`
 - `dist`
@@ -154,113 +280,84 @@ AgentRinse has two mutation classes.
 - `target`
 - `.venv`
 
-Before removal it revalidates configured scope, canonical paths, device and
-inode identity, recursive metadata fingerprint, measured bytes, newest
-descendant age, mount boundaries, current working directory ownership,
-same-user processes, and plan expiration. The exact target is atomically moved
-to a same-parent tombstone and verified again before deletion.
+before removal, agentrinse revalidates configured scope, canonical path,
+device and inode identity, recursive metadata fingerprint, measured bytes,
+newest descendant age, mount boundaries, current working directories,
+same-user processes, and plan expiration.
 
-`recoverable` worktree quarantine supports only linked, unlocked, clean,
-pushed, branch-attached worktrees with complete measurement, no submodules,
-no live process, no pin or provider root, and sufficient age. A recovery ref
-is created before atomic same-filesystem rename. Git registration is repaired,
-locked, verified, and recorded in an owner-only manifest.
+### worktree quarantine
 
-Permanent purge reloads configuration and provider workspace metadata under
-the mutation lock. A current path, resource-ID, or Git-ref pin, provider-managed
-root, active/recent session, or unknown provider state protects the original,
-quarantine, or purge-isolation location and refuses deletion. The refresh runs
-again immediately before every normal or resumed permanent removal.
+a worktree is eligible for recoverable quarantine only when agentrinse can
+prove that it is:
 
-AgentRinse never removes provider sessions, transcripts, databases,
-credentials, configuration, plugins, skills, memories, Git branches, stashes,
-Docker images, containers, networks, volumes, or build cache in `0.3.0`.
+- linked, unlocked, branch-attached, clean, and pushed
+- old enough under the configured policy
+- free of submodules and active same-user processes
+- outside the current and main worktrees
+- not pinned by a Git ref, provider root, or active/recent agent session
+- completely measured with no unknown ownership state
 
-## Operations
+a recovery ref is created before the atomic move. Git registration is repaired
+and locked, then the quarantine manifest is written with owner-only
+permissions. permanent purge reloads configuration and provider metadata under
+the mutation lock and refuses removal if any protection fact has changed.
 
-```bash
-agentrinse history
-agentrinse show run <run-id>
-agentrinse show plan <plan-id>
-agentrinse show resource <resource-id>
-agentrinse undo <run-id>
-agentrinse purge
-agentrinse purge --expired --apply --yes
-agentrinse lock status
-```
+## machine output
 
-Opt into report-only selected runtime inventory:
-
-```json
-{
-  "schemaVersion": 1,
-  "adapters": {
-    "runtime": { "enabled": true }
-  }
-}
-```
-
-A stale lock can be recovered only after AgentRinse proves the recorded local
-process identity no longer exists:
+`--json` emits a versioned command envelope suitable for scripts and agent
+tools:
 
 ```bash
-agentrinse lock status
-agentrinse lock recover --yes
+agentrinse audit --json
+agentrinse clean --profile closeout --json
+agentrinse history --json
 ```
 
-Generate shell completion without modifying shell startup files:
-
-```bash
-agentrinse completion bash
-agentrinse completion zsh
-agentrinse completion fish
-```
-
-## Machine Output
-
-`agentrinse audit --json` emits a versioned command envelope. Long audits can
-emit incremental event records:
+long audits can stream versioned events:
 
 ```bash
 agentrinse audit --ndjson
 ```
 
-Create a non-executable report for issue filing:
+create a non-executable report for issue filing:
 
 ```bash
 agentrinse audit --json --redact > audit-redacted.json
 ```
 
-Redaction replaces paths, salts identifiers per report, removes host fields,
-and strips candidate actions. Persisted state and `--output` evidence remain
-exact so they can be used for planning.
+redaction replaces paths, salts identifiers per report, removes host fields,
+and strips candidate actions. saved audit and plan evidence remains exact so
+it can be verified before apply.
 
-## Platform Support
+## platform support
 
-| Platform       | `0.3.0` support                                         |
-| -------------- | ------------------------------------------------------- |
-| macOS          | audit, artifact removal, worktree quarantine/undo/purge |
-| Linux          | audit, artifact removal, worktree quarantine/undo/purge |
-| WSL            | Linux contract inside the WSL filesystem                |
-| native Windows | audit-only; mutation remains blocked before `1.0.0`     |
+| Platform       | `0.5.0` support                                                 |
+| -------------- | --------------------------------------------------------------- |
+| macOS          | audit, artifact/worktree/Claude cleanup, DB vacuum, undo, purge |
+| Linux          | audit, artifact/worktree/Claude cleanup, DB vacuum, undo, purge |
+| WSL            | Linux contract inside the WSL filesystem                        |
+| native Windows | audit-only; mutation remains blocked before `1.0.0`             |
 
 Git and `lsof` are required for the complete diagnostic and process-ownership
-contract. Docker is optional. Doctor can detect the optional external Mole
-tool on macOS.
-
-## Documentation
-
-- [Configuration](docs/configuration.md)
-- [Automation](docs/automation.md)
-- [Recovery](docs/recovery.md)
-- [Platform support](docs/platforms.md)
-- [Safety model](docs/safety.md)
-- [Adapter matrix](docs/adapters.md)
-- [Development](docs/development.md)
-- [Releasing](docs/releasing.md)
-- [Product specification](docs/product-spec.md)
-
-## Development
+contract. Codex DB maintenance additionally requires `sqlite3`. Docker is
+optional. Mole detection is available on macOS.
+
+## docs
+
+- [configuration](docs/configuration.md)
+- [automation](docs/automation.md)
+- [recovery](docs/recovery.md)
+- [safety model](docs/safety.md)
+- [adapter matrix](docs/adapters.md)
+- [platform support](docs/platforms.md)
+- [architecture](docs/architecture.md)
+- [development](docs/development.md)
+- [release process](docs/releasing.md)
+- [roadmap](docs/roadmap.md)
+- [product specification](docs/product-spec.md)
+- [security policy](SECURITY.md)
+
+## development
 
 ```bash
 pnpm install
@@ -269,9 +366,14 @@ pnpm smoke
 pnpm pack:check
 ```
 
-Tests and smoke runs use guarded temporary synthetic roots. Never point an
+tests and smoke runs use guarded temporary synthetic roots. never point an
 unreleased build at real developer state.
 
-## License
+## status
+
+`0.5.0` ships the complete audit → plan → revalidate → apply loop, safe
+configured artifact cleanup, recoverable Git worktree and Claude file
+quarantine, and recoverable offline Codex database compaction. Cursor, Zed,
+OpenCode, Grok Build, and Docker remain report-only.
 
-MIT
+MIT licensed. built by [Vincent Koc](https://github.com/vincentkoc).

package/dist/adapters/claude-cache.d.ts

@@ -0,0 +1,3 @@
+import type { AuditContext, CollectionResult } from "../contracts/adapter.js";
+export declare function collectClaudeChangelogCache(context: AuditContext, ownerRoot: string): Promise<CollectionResult>;
+//# sourceMappingURL=claude-cache.d.ts.map

package/dist/adapters/claude-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-cache.d.ts","sourceRoot":"","sources":["../../src/adapters/claude-cache.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAc9E,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,YAAY,EACrB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,gBAAgB,CAAC,CA2D3B"}

package/dist/adapters/claude-cache.js

@@ -0,0 +1,67 @@
+import { lstat } from "node:fs/promises";
+import { join } from "node:path";
+import { sha256 } from "../core/digest.js";
+import { inspectProviderFile } from "../core/provider-file-identity.js";
+import { CLAUDE_CHANGELOG_CACHE_MIN_AGE_MINUTES, CLAUDE_CHANGELOG_CACHE_POLICY_ID, } from "../core/provider-file-policy.js";
+function isMissing(error) {
+    return (error instanceof Error && "code" in error && error.code === "ENOENT");
+}
+export async function collectClaudeChangelogCache(context, ownerRoot) {
+    const cacheRoot = join(ownerRoot, "cache");
+    const path = join(cacheRoot, "changelog.md");
+    try {
+        const cacheStats = await lstat(cacheRoot);
+        if (cacheStats.isSymbolicLink() || !cacheStats.isDirectory()) {
+            return { resources: [], diagnostics: [] };
+        }
+        const stats = await lstat(path);
+        const cutoffMs = context.now.getTime() - CLAUDE_CHANGELOG_CACHE_MIN_AGE_MINUTES * 60_000;
+        if (!stats.isFile() || stats.isSymbolicLink() || stats.mtimeMs > cutoffMs) {
+            return { resources: [], diagnostics: [] };
+        }
+        const identity = await inspectProviderFile(path, ownerRoot, "claude");
+        const canonicalKey = `claude:changelog-cache:${identity.path}`;
+        return {
+            resources: [
+                {
+                    resource: {
+                        id: `claude:agent-cache:${sha256(canonicalKey)}`,
+                        adapter: "claude",
+                        kind: "agent-cache",
+                        canonicalKey,
+                        displayName: "Claude changelog cache",
+                        path: identity.path,
+                    },
+                    observedAt: context.now.toISOString(),
+                    exists: true,
+                    measuredBytes: identity.measuredBytes,
+                    facts: {
+                        reportOnly: false,
+                        maintenanceAction: "provider.file-quarantine",
+                        policyId: CLAUDE_CHANGELOG_CACHE_POLICY_ID,
+                        minAgeMinutes: CLAUDE_CHANGELOG_CACHE_MIN_AGE_MINUTES,
+                        providerFileIdentity: identity,
+                    },
+                },
+            ],
+            diagnostics: [],
+        };
+    }
+    catch (error) {
+        if (isMissing(error)) {
+            return { resources: [], diagnostics: [] };
+        }
+        return {
+            resources: [],
+            diagnostics: [
+                {
+                    severity: "warning",
+                    code: "CLAUDE_CHANGELOG_CACHE_INSPECTION_FAILED",
+                    message: error instanceof Error ? error.message : String(error),
+                    adapter: "claude",
+                },
+            ],
+        };
+    }
+}
+//# sourceMappingURL=claude-cache.js.map

package/dist/adapters/claude-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-cache.js","sourceRoot":"","sources":["../../src/adapters/claude-cache.ts"],"names":[],"mappings":"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"}

package/dist/adapters/claude-debug.d.ts

@@ -0,0 +1,3 @@
+import type { AuditContext, CollectionResult } from "../contracts/adapter.js";
+export declare function collectClaudeDebugLogs(context: AuditContext, ownerRoot: string, maxEntries: number): Promise<CollectionResult>;
+//# sourceMappingURL=claude-debug.d.ts.map

package/dist/adapters/claude-debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-debug.d.ts","sourceRoot":"","sources":["../../src/adapters/claude-debug.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAgB9E,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,YAAY,EACrB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,gBAAgB,CAAC,CA6F3B"}