From 2f9138ec4a14ced9ad4537e614ac4b8fdf0e99a1 Mon Sep 17 00:00:00 2001 From: Chris Jackson <201591867+chrisjackson-coding@users.noreply.github.com> Date: Tue, 25 Aug 2026 10:15:25 +0100 Subject: [PATCH 1/7] Make the feature-adoption log actually record what you use usage_log.md drives /dex-level-up: it records which Dex features a vault has used so the skill can recommend the ones it has not. mark_feature_used() is the documented way to record that, and it could not do it. Three separate reasons, each of which alone would be enough: 1. It was never exposed as a tool. The only documented caller is a skill, and skills reach Python through MCP. The function has lived in analytics_helper.py unreachable from the place the checklist tells authors to call it from. 2. Its pattern could not match most of the file. The label matcher used [^(\\n]* around the feature name, which stops at the first bracket, so any entry written as "Daily planning (\`/daily-plan\`)" was unmatchable. On a real vault that is 37 of 61 remaining features. 3. It returned None whether it worked or not. A caller could not tell a successful tick from a no-op, so a miss looked exactly like a hit. That is why the drift was invisible: the log on the vault this was found on had not changed in twelve days while the features were in daily use. This replaces the matcher with an ordered one (slash command, then exact label, then label with the command stripped), returns a status instead of None, refuses to guess when several entries match, and writes through a temp file so an interrupted write cannot truncate the consent records that share this file. Adoption tracking is deliberately NOT gated on analytics consent, and there is a test for that: it writes to the vault and sends nothing, and the recommendations it feeds are useful whether or not a user shares anything. The parsed feature map in load_usage_log() had no consumers, so the read side was dead too. A test now covers the loop end to end. Co-authored-by: davekilleen --- .../reference/skill-analytics-checklist.md | 23 +- core/mcp/analytics_helper.py | 143 +++++++++--- core/mcp/analytics_server.py | 31 +++ core/tests/test_usage_tracking.py | 207 ++++++++++++++++++ 4 files changed, 375 insertions(+), 29 deletions(-) create mode 100644 core/tests/test_usage_tracking.py diff --git a/.claude/reference/skill-analytics-checklist.md b/.claude/reference/skill-analytics-checklist.md index 38cac9caf..466d68143 100644 --- a/.claude/reference/skill-analytics-checklist.md +++ b/.claude/reference/skill-analytics-checklist.md @@ -67,12 +67,19 @@ Add to your skill's SKILL.md (at the end of the workflow): ```markdown ## Analytics -At completion, if analytics is enabled: +At completion: -1. Fire event: `fire_event('your_skill_completed', {'items': count, 'mode': selected_mode})` -2. Mark feature used: `mark_feature_used('Your feature name')` +1. Fire event (only if analytics is enabled): + `fire_event('your_skill_completed', {'items': count, 'mode': selected_mode})` +2. Record adoption (always, analytics or not): call the `mark_feature_used` tool on the + `dex-analytics` MCP server with your skill's slash command, e.g. `daily-plan`. ``` +**These two are not the same thing.** `fire_event` sends a product event and is gated on +analytics consent. `mark_feature_used` ticks a box in `System/usage_log.md`, writes nothing +anywhere else, and runs regardless of consent, because `/dex-level-up` reads that file to +recommend features the user has not tried yet. + Or for MCP tools, add to the Python handler: ```python @@ -80,9 +87,17 @@ from analytics_helper import fire_event, mark_feature_used # At end of tool execution fire_event('tool_name_used', {'property': value}) -mark_feature_used('Feature name') + +# Identify the feature by its slash command, or by the exact label in usage_log.md +result = mark_feature_used('your-skill') +# result['status'] is one of: +# marked | already_marked | ambiguous | not_found | unavailable ``` +**Check the status.** `not_found` means the feature has no line in `usage_log.md` and the +call did nothing; `ambiguous` means several lines matched and it refused to guess. Both are +returned rather than raised, so they will pass silently if nobody looks. + --- ## 5. Privacy Check diff --git a/core/mcp/analytics_helper.py b/core/mcp/analytics_helper.py index 42a0a2c42..b2ea2602c 100644 --- a/core/mcp/analytics_helper.py +++ b/core/mcp/analytics_helper.py @@ -21,7 +21,7 @@ import sys from datetime import datetime, timezone from pathlib import Path -from typing import Any, Dict, Optional +from typing import Any, Dict, List, Optional _REPO_ROOT = Path(__file__).resolve().parents[2] if str(_REPO_ROOT) not in sys.path: @@ -157,9 +157,26 @@ def get_analytics_transport() -> Dict[str, Any]: } +# One definition of where the adoption log lives, so the reader and the writer +# below can never disagree about the file they are talking about. +USAGE_LOG_RELATIVE_PARTS = ('System', 'usage_log.md') + +# A feature line looks like "- [ ] Daily planning (`/daily-plan`)". Group 2 is the +# only character this module ever rewrites. +_CHECKBOX_RE = re.compile(r'^(\s*-\s+\[)([ xX])(\]\s+)(\S.*?)\s*$') + +# The slash-command inside a label, e.g. "(`/daily-plan`)" -> "daily-plan". +_COMMAND_RE = re.compile(r'`/([a-z0-9][a-z0-9-]*)`', re.IGNORECASE) + + +def get_usage_log_path() -> Path: + """Absolute path to the adoption log.""" + return get_vault_path().joinpath(*USAGE_LOG_RELATIVE_PARTS) + + def load_usage_log() -> Dict[str, Any]: """Parse usage_log.md into structured data.""" - usage_path = get_vault_path() / 'System' / 'usage_log.md' + usage_path = get_usage_log_path() if not usage_path.exists(): return {} @@ -197,6 +214,105 @@ def load_usage_log() -> Dict[str, Any]: return data +def _match_feature_lines(lines: List[str], feature: str) -> List[int]: + """Line indexes whose checkbox label identifies `feature`. + + Matching is deliberately narrow and ordered, so a caller either gets one + obvious line or an honest report that it could not tell them apart: + + 1. the slash-command in the label ("/daily-plan" matches "(`/daily-plan`)") + 2. the whole label, case-insensitively + 3. the label with its command stripped, case-insensitively + + A broader fuzzy fallback is deliberately absent: silently marking the wrong + milestone is worse than reporting that the name was ambiguous. + """ + wanted = feature.strip().lstrip('/').strip() + if not wanted: + return [] + wanted_lower = wanted.lower() + + by_command: List[int] = [] + by_label: List[int] = [] + for index, line in enumerate(lines): + match = _CHECKBOX_RE.match(line) + if not match: + continue + label = match.group(4).strip() + commands = [c.lower() for c in _COMMAND_RE.findall(label)] + if wanted_lower in commands: + by_command.append(index) + continue + bare = _COMMAND_RE.sub('', label).strip(' ()').strip() + if label.lower() == wanted_lower or bare.lower() == wanted_lower: + by_label.append(index) + + return by_command or by_label + + +def mark_feature_used(feature: str) -> Dict[str, Any]: + """Tick one adoption checkbox in usage_log.md. + + Local bookkeeping only. This never sends anything, and it is deliberately + NOT gated on analytics consent: the log records which Dex features this + vault has used so `/dex-level-up` can recommend the ones it has not, which + is useful whether or not the user shares anything. + + Returns a status rather than raising, so a caller can record the outcome + without a failure interrupting the work the user actually asked for: + + marked - a box was unticked and is now ticked + already_marked - the box was already ticked, nothing written + ambiguous - several boxes match; candidates returned, nothing written + not_found - no box matches that feature + unavailable - the log is missing or could not be read + """ + usage_path = get_usage_log_path() + try: + content = usage_path.read_text(encoding='utf-8') + except FileNotFoundError: + return {'status': 'unavailable', 'feature': feature, 'reason': 'usage log not found'} + except OSError as exc: + return {'status': 'unavailable', 'feature': feature, 'reason': str(exc)} + + lines = content.splitlines(keepends=True) + matches = _match_feature_lines(lines, feature) + + if not matches: + return {'status': 'not_found', 'feature': feature} + + if len(matches) > 1: + candidates = [_CHECKBOX_RE.match(lines[i]).group(4).strip() for i in matches] + return {'status': 'ambiguous', 'feature': feature, 'candidates': candidates} + + index = matches[0] + match = _CHECKBOX_RE.match(lines[index]) + label = match.group(4).strip() + if match.group(2).lower() == 'x': + return {'status': 'already_marked', 'feature': feature, 'label': label} + + ending = '' + body = lines[index] + while body.endswith(('\n', '\r')): + ending = body[-1] + ending + body = body[:-1] + match = _CHECKBOX_RE.match(body) + lines[index] = f"{match.group(1)}x{match.group(3)}{match.group(4)}{ending}" + + updated = ''.join(lines) + # Write via a sibling temp file and replace, so an interrupted write can + # never leave a half-written consent record behind. + temp_path = usage_path.with_name(usage_path.name + '.tmp') + try: + temp_path.write_text(updated, encoding='utf-8') + os.replace(temp_path, usage_path) + except OSError as exc: + temp_path.unlink(missing_ok=True) + return {'status': 'unavailable', 'feature': feature, 'reason': str(exc)} + + return {'status': 'marked', 'feature': feature, 'label': label} + + def check_consent() -> str: """ Check analytics consent status. @@ -577,29 +693,6 @@ def update_consent(decision: str): f.write(content) -def mark_feature_used(feature_name: str): - """Mark a feature as used in usage_log.md.""" - usage_path = get_vault_path() / 'System' / 'usage_log.md' - if not usage_path.exists(): - return - - with open(usage_path, 'r') as f: - content = f.read() - - # Find and check the checkbox for this feature - # Pattern: - [ ] Feature name... → - [x] Feature name... - pattern = rf'- \[ \] ([^(\n]*{re.escape(feature_name)}[^(\n]*)' - - def replace_checkbox(match): - return f'- [x] {match.group(1)}' - - new_content = re.sub(pattern, replace_checkbox, content, flags=re.IGNORECASE) - - if new_content != content: - with open(usage_path, 'w') as f: - f.write(new_content) - - # Event name constants for consistency class Events: # Lifecycle diff --git a/core/mcp/analytics_server.py b/core/mcp/analytics_server.py index f62b253a8..54371aabd 100644 --- a/core/mcp/analytics_server.py +++ b/core/mcp/analytics_server.py @@ -43,6 +43,7 @@ get_visitor_info, is_analytics_enabled, load_user_profile, + mark_feature_used, ) from core.utils.feature_status import feature_status @@ -126,6 +127,31 @@ async def list_tools(): "required": [] } ), + Tool( + name="mark_feature_used", + description=( + "Record that a Dex feature has been used, by ticking its box in " + "System/usage_log.md. Local bookkeeping only: this writes to the vault and " + "sends nothing, so it runs regardless of analytics consent. Call it when a " + "skill completes, so /dex-level-up recommends features the user has not yet " + "tried instead of ones they use daily." + ), + inputSchema={ + "type": "object", + "properties": { + "feature": { + "type": "string", + "description": ( + "The feature to mark, identified by its slash command without the " + "leading slash (e.g. 'daily-plan'), or by its exact label in the log " + "(e.g. 'Person page created'). Ambiguous names are reported back " + "with the candidates rather than guessed at." + ) + } + }, + "required": ["feature"] + } + ), Tool( name="test_connection", description="Test Pendo connection with a test event.", @@ -154,6 +180,11 @@ async def call_tool(name: str, arguments: dict) -> list[TextContent]: raise async def _call_tool_inner(name: str, arguments: dict) -> list[TextContent]: + if name == "mark_feature_used": + # Deliberately not consent-gated: nothing leaves the machine. + result = mark_feature_used(arguments["feature"]) + return [TextContent(type="text", text=json.dumps(result, indent=2))] + if name == "check_analytics_status": enabled = is_analytics_enabled() consent = check_consent() diff --git a/core/tests/test_usage_tracking.py b/core/tests/test_usage_tracking.py new file mode 100644 index 000000000..1d0f5651d --- /dev/null +++ b/core/tests/test_usage_tracking.py @@ -0,0 +1,207 @@ +"""Proof that marking a feature as used actually writes, and never writes the wrong thing. + +The adoption checkboxes in usage_log.md had a reader and no writer: 34 skills +instructed the assistant to hand-edit the file, nothing verified that it had, +and a run where the edit was skipped looked exactly like a run where it was not. +These tests exist so that failure mode cannot come back silently. +""" + +from __future__ import annotations + +from pathlib import Path + +import pytest + +from core.mcp import analytics_helper + +LOG_WITH_CONSENT = """# Dex Usage Tracking + +**Consent asked:** yes +**Consent decision:** opted-in +**Health telemetry:** opted-out + +## Core Workflows + +- [x] Daily planning (`/daily-plan`) +- [ ] Meeting prep (`/meeting-prep`) +- [ ] Person page created +- [ ] Journaling (`/journal`) +- [ ] Journaling setup (`/journal`) +""" + + +@pytest.fixture +def vault(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path: + (tmp_path / "System").mkdir(parents=True) + (tmp_path / "System" / "usage_log.md").write_text(LOG_WITH_CONSENT, encoding="utf-8") + monkeypatch.setenv("VAULT_PATH", str(tmp_path)) + return tmp_path + + +def _log(vault: Path) -> str: + return (vault / "System" / "usage_log.md").read_text(encoding="utf-8") + + +def test_marking_an_unticked_feature_writes_the_box(vault: Path) -> None: + result = analytics_helper.mark_feature_used("meeting-prep") + + assert result["status"] == "marked" + assert result["label"] == "Meeting prep (`/meeting-prep`)" + assert "- [x] Meeting prep (`/meeting-prep`)" in _log(vault) + + +def test_a_leading_slash_is_accepted(vault: Path) -> None: + assert analytics_helper.mark_feature_used("/meeting-prep")["status"] == "marked" + assert "- [x] Meeting prep (`/meeting-prep`)" in _log(vault) + + +def test_a_plain_label_without_a_command_is_matched(vault: Path) -> None: + result = analytics_helper.mark_feature_used("Person page created") + + assert result["status"] == "marked" + assert "- [x] Person page created" in _log(vault) + + +def test_marking_twice_is_idempotent_and_writes_nothing_the_second_time(vault: Path) -> None: + analytics_helper.mark_feature_used("meeting-prep") + after_first = _log(vault) + + result = analytics_helper.mark_feature_used("meeting-prep") + + assert result["status"] == "already_marked" + assert _log(vault) == after_first + + +def test_an_ambiguous_name_reports_candidates_and_changes_nothing(vault: Path) -> None: + before = _log(vault) + + result = analytics_helper.mark_feature_used("journal") + + assert result["status"] == "ambiguous" + assert sorted(result["candidates"]) == [ + "Journaling (`/journal`)", + "Journaling setup (`/journal`)", + ] + assert _log(vault) == before + + +def test_an_unknown_feature_changes_nothing(vault: Path) -> None: + before = _log(vault) + + assert analytics_helper.mark_feature_used("no-such-skill")["status"] == "not_found" + assert _log(vault) == before + + +def test_consent_lines_are_never_touched(vault: Path) -> None: + analytics_helper.mark_feature_used("meeting-prep") + updated = _log(vault) + + assert "**Consent asked:** yes" in updated + assert "**Consent decision:** opted-in" in updated + assert "**Health telemetry:** opted-out" in updated + assert analytics_helper.check_consent() == "opted-in" + + +def test_every_other_line_survives_byte_for_byte(vault: Path) -> None: + before = _log(vault).splitlines() + + analytics_helper.mark_feature_used("meeting-prep") + + after = _log(vault).splitlines() + assert len(before) == len(after) + changed = [(b, a) for b, a in zip(before, after) if b != a] + assert changed == [ + ("- [ ] Meeting prep (`/meeting-prep`)", "- [x] Meeting prep (`/meeting-prep`)") + ] + + +def test_a_missing_log_is_reported_not_raised(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.setenv("VAULT_PATH", str(tmp_path)) + + result = analytics_helper.mark_feature_used("meeting-prep") + + assert result["status"] == "unavailable" + assert not (tmp_path / "System" / "usage_log.md").exists() + + +def test_marking_leaves_no_temp_file_behind(vault: Path) -> None: + analytics_helper.mark_feature_used("meeting-prep") + + assert list((vault / "System").glob("*.tmp")) == [] + + +def test_marking_never_sends_anything(vault: Path, monkeypatch: pytest.MonkeyPatch) -> None: + """Local bookkeeping must not depend on, or trigger, the analytics transport.""" + def explode(*args: object, **kwargs: object) -> None: + raise AssertionError("mark_feature_used must not fire an analytics event") + + monkeypatch.setattr(analytics_helper, "fire_event", explode) + + assert analytics_helper.mark_feature_used("meeting-prep")["status"] == "marked" + + +def test_it_runs_when_analytics_consent_is_declined(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + """Adoption tracking is local, so opting out of analytics must not disable it.""" + (tmp_path / "System").mkdir(parents=True) + (tmp_path / "System" / "usage_log.md").write_text( + LOG_WITH_CONSENT.replace("opted-in", "opted-out"), encoding="utf-8" + ) + monkeypatch.setenv("VAULT_PATH", str(tmp_path)) + + assert analytics_helper.check_consent() == "opted-out" + assert analytics_helper.is_analytics_enabled() is False + assert analytics_helper.mark_feature_used("meeting-prep")["status"] == "marked" + + +def test_the_reader_sees_what_the_writer_wrote(vault: Path) -> None: + """The parsed feature map was dead code; this is the loop closing.""" + assert analytics_helper.load_usage_log()["features"]["Meeting prep (`/meeting-prep`)"] is False + + analytics_helper.mark_feature_used("meeting-prep") + + assert analytics_helper.load_usage_log()["features"]["Meeting prep (`/meeting-prep`)"] is True + + +# --- the tool has to be reachable, which is the half that was missing --- + + +def _decode(result: list) -> dict: + import json + + return json.loads(result[0].text) + + +def test_the_tool_is_registered_on_the_analytics_server() -> None: + """The helper existed for months but no skill could reach it.""" + import asyncio + + from core.mcp import analytics_server + + names = {tool.name for tool in asyncio.run(analytics_server.list_tools())} + + assert "mark_feature_used" in names + + +def test_the_registered_tool_marks_a_feature_end_to_end(vault: Path) -> None: + import asyncio + + from core.mcp import analytics_server + + payload = _decode( + asyncio.run(analytics_server.call_tool("mark_feature_used", {"feature": "meeting-prep"})) + ) + + assert payload["status"] == "marked" + assert "- [x] Meeting prep (`/meeting-prep`)" in _log(vault) + + +def test_the_registered_tool_reports_an_unknown_feature_rather_than_failing(vault: Path) -> None: + import asyncio + + from core.mcp import analytics_server + + payload = _decode( + asyncio.run(analytics_server.call_tool("mark_feature_used", {"feature": "no-such-skill"})) + ) + + assert payload["status"] == "not_found" From 10317cd83e27e9b1e1aebcaf015e79f2b5d83fc3 Mon Sep 17 00:00:00 2001 From: Chris Jackson <201591867+chrisjackson-coding@users.noreply.github.com> Date: Tue, 25 Aug 2026 18:17:20 +0100 Subject: [PATCH 2/7] Move the adoption-log write behind a lifecycle operation Review of #590: mark_feature_used wrote System/usage_log.md directly, which breaks Dex's vault-mutation contract and is unsafe three ways. All three reproduce against the old approach and are now covered by tests: - a vault whose System directory is a symlink had the write land outside the vault entirely; - a 0600 log became 0644, because write_text on a fresh temporary takes the umask and the rename carries it; - the fixed .tmp sibling is the same path for both writers, so a feature tick and a consent update could each read, modify and write the whole file and silently lose the other's change. Adds rewrite_usage_log() to core/lifecycle/service.py, modelled on the existing analytics-receipt seam: whole-route symlink validation before the file is read, a refusal on a symlinked target, bounded read, expected-SHA guard with stale retry, and the existing mode re-stated in the plan so a write can never loosen it. Scoped by the contract rather than by the caller. The new usage-log operation is authorised for exactly one path, so it cannot write anything else even if a future caller asks it to, and the bounded-read limit is registered at both engine sites. update_consent now uses the same door, per the review: with two direct writers the concurrency guarantee would not have been real. The MCP helper keeps its matching and its five statuses. It decides the outcome from a plain read so a no-op never opens a transaction, and its transform re-matches against the text the transaction actually read, because a retry may run it again after another writer has ticked the same box. 251 tests pass across usage tracking, the portable contract, the transaction core, analytics wiring, instruction honesty and the lifecycle contract. --- core/lifecycle/service.py | 97 +++++++++++++++++++- core/mcp/analytics_helper.py | 126 +++++++++++++++----------- core/portable_contract.py | 44 +++++++++ core/tests/test_usage_tracking.py | 145 ++++++++++++++++++++++++++++++ core/transaction/engine.py | 12 +++ 5 files changed, 371 insertions(+), 53 deletions(-) diff --git a/core/lifecycle/service.py b/core/lifecycle/service.py index 2ec059d9e..0ef60539a 100644 --- a/core/lifecycle/service.py +++ b/core/lifecycle/service.py @@ -88,6 +88,8 @@ portable_contract.ANALYTICS_ATTEMPT_RECEIPT_MAX_EXISTING_BYTES ) _ANALYTICS_RECEIPT_APPEND_ATTEMPTS = 2 +_USAGE_LOG_RELATIVE = portable_contract.USAGE_LOG_RELATIVE +_USAGE_LOG_REWRITE_ATTEMPTS = 3 _ANALYTICS_RECEIPT_TIMESTAMP = re.compile( r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?\+00:00$" ) @@ -142,6 +144,8 @@ def _internal_transaction_read_limits(operation: str) -> dict[str, int]: portable_contract.ANALYTICS_ATTEMPT_RECEIPT_TRANSACTION_MAX_BYTES ) } + if operation == "usage-log": + return {_USAGE_LOG_RELATIVE: portable_contract.USAGE_LOG_TRANSACTION_MAX_BYTES} if operation == "automation-ownership": return { automation_ownership.SIDECAR_RELATIVE: automation_ownership.SIDECAR_MAX_BYTES, @@ -441,12 +445,12 @@ def _retain_newest_analytics_receipt_records( return retained -def _is_stale_analytics_receipt_plan(error: PlanRejected) -> bool: - """Recognize only a stale precondition for this one local receipt file.""" +def _is_stale_runtime_file_plan(error: PlanRejected, relative: str) -> bool: + """Recognize only a stale precondition for one named runtime file.""" message = str(error) if message == "transaction approval token does not match the current preview": return True - if _ANALYTICS_ATTEMPT_RECEIPT_RELATIVE not in message: + if relative not in message: return False return any( marker in message @@ -460,6 +464,93 @@ def _is_stale_analytics_receipt_plan(error: PlanRejected) -> bool: ) +def _is_stale_analytics_receipt_plan(error: PlanRejected) -> bool: + """Back-compat shim for the receipt caller.""" + return _is_stale_runtime_file_plan(error, _ANALYTICS_ATTEMPT_RECEIPT_RELATIVE) + + +def rewrite_usage_log( + vault_root: str | Path, + transform: Callable[[str], str | None], +) -> dict[str, object]: + """Rewrite ``System/usage_log.md`` through the transaction core. + + The adoption log has two mutators, feature ticks and consent decisions, and + both must come through here. Writing it directly is unsafe in three ways + this operation closes: + + * a vault whose ``System`` directory is a symlink could put the write + outside the vault, so the whole route is validated before the file is + even read; + * a plain write plus rename takes the umask, silently loosening a log a + user has tightened, so the existing mode is read and re-planned; + * a fixed temporary sibling lets a feature tick and a consent update race + and lose one whole-file change, so the write is guarded by the current + digest and retried when it goes stale. + + ``transform`` receives the current text and returns replacement text, or + ``None`` to make no change. It must be pure and cheap: it can be called + again on a retry. + """ + root = Path(vault_root) + for attempt in range(_USAGE_LOG_REWRITE_ATTEMPTS): + unsafe_parent = unsafe_existing_parent(root, _USAGE_LOG_RELATIVE) + if unsafe_parent is not None: + raise PlanRejected(f"usage log: {unsafe_parent}") + target = root / _USAGE_LOG_RELATIVE + if target.is_symlink(): + raise PlanRejected("usage log target must be a regular file") + if not target.exists(): + raise PlanRejected("usage log does not exist") + if not target.is_file(): + raise PlanRejected("usage log target must be a regular file") + + existing = bounded_read( + root, + _USAGE_LOG_RELATIVE, + max_bytes=portable_contract.USAGE_LOG_TRANSACTION_MAX_BYTES, + ) + try: + current = existing.decode("utf-8") + except UnicodeDecodeError as error: + raise PlanRejected(f"usage log is not valid UTF-8: {error}") from error + + updated = transform(current) + if updated is None or updated == current: + return _envelope(status="unchanged", relative=_USAGE_LOG_RELATIVE) + + # Preserve whatever the user has set. A write must never loosen it. + mode = target.stat().st_mode & 0o777 + + plan = [ + PlanEntry( + _USAGE_LOG_RELATIVE, + updated.encode("utf-8"), + mode=mode, + expected_current_sha256=hashlib.sha256(existing).hexdigest(), + ) + ] + preview = _preview_transaction( + root, plan, purpose="usage-log", operation="usage-log" + ) + try: + result = _execute_approved_transaction( + root, + plan, + purpose="usage-log", + operation="usage-log", + approved_token=str(preview["approval_token"]), + ) + except PlanRejected as error: + if attempt + 1 < _USAGE_LOG_REWRITE_ATTEMPTS and _is_stale_runtime_file_plan( + error, _USAGE_LOG_RELATIVE + ): + continue + raise + return _envelope(status="written", relative=_USAGE_LOG_RELATIVE, receipt=result) + raise PlanRejected("usage log changed repeatedly while being rewritten") + + def _append_analytics_attempt_receipt( vault_root: str | Path, *, diff --git a/core/mcp/analytics_helper.py b/core/mcp/analytics_helper.py index b2ea2602c..508cb8064 100644 --- a/core/mcp/analytics_helper.py +++ b/core/mcp/analytics_helper.py @@ -214,6 +214,20 @@ def load_usage_log() -> Dict[str, Any]: return data +def _rewrite_usage_log_safely(transform): + """Route every adoption-log write through the lifecycle transaction core. + + Dex's vault-mutation contract requires vault writes to go through + `core/lifecycle/service.py`. Writing this file directly is unsafe against a + symlinked `System` directory, silently loosens a tightened file mode, and + lets a feature tick race a consent update. Imported lazily so the MCP + helper keeps starting on installs that do not carry the lifecycle package. + """ + from core.lifecycle.service import rewrite_usage_log + + return rewrite_usage_log(get_vault_path(), transform) + + def _match_feature_lines(lines: List[str], feature: str) -> List[int]: """Line indexes whose checkbox label identifies `feature`. @@ -275,6 +289,8 @@ def mark_feature_used(feature: str) -> Dict[str, Any]: except OSError as exc: return {'status': 'unavailable', 'feature': feature, 'reason': str(exc)} + # Decide the outcome from a plain read first, so the caller gets the same + # statuses as before without opening a transaction for a no-op. lines = content.splitlines(keepends=True) matches = _match_feature_lines(lines, feature) @@ -285,31 +301,39 @@ def mark_feature_used(feature: str) -> Dict[str, Any]: candidates = [_CHECKBOX_RE.match(lines[i]).group(4).strip() for i in matches] return {'status': 'ambiguous', 'feature': feature, 'candidates': candidates} - index = matches[0] - match = _CHECKBOX_RE.match(lines[index]) - label = match.group(4).strip() - if match.group(2).lower() == 'x': + label = _CHECKBOX_RE.match(lines[matches[0]]).group(4).strip() + if _CHECKBOX_RE.match(lines[matches[0]]).group(2).lower() == 'x': return {'status': 'already_marked', 'feature': feature, 'label': label} - ending = '' - body = lines[index] - while body.endswith(('\n', '\r')): - ending = body[-1] + ending - body = body[:-1] - match = _CHECKBOX_RE.match(body) - lines[index] = f"{match.group(1)}x{match.group(3)}{match.group(4)}{ending}" - - updated = ''.join(lines) - # Write via a sibling temp file and replace, so an interrupted write can - # never leave a half-written consent record behind. - temp_path = usage_path.with_name(usage_path.name + '.tmp') + def _tick(current: str) -> Optional[str]: + """Re-match against the text the transaction actually read. + + This runs again on a stale retry, so it must not close over the + content read above: another writer may have ticked this very box. + """ + rows = current.splitlines(keepends=True) + found = _match_feature_lines(rows, feature) + if len(found) != 1: + return None + index = found[0] + body = rows[index] + ending = '' + while body.endswith(('\n', '\r')): + ending = body[-1] + ending + body = body[:-1] + match = _CHECKBOX_RE.match(body) + if match is None or match.group(2).lower() == 'x': + return None + rows[index] = f"{match.group(1)}x{match.group(3)}{match.group(4)}{ending}" + return ''.join(rows) + try: - temp_path.write_text(updated, encoding='utf-8') - os.replace(temp_path, usage_path) - except OSError as exc: - temp_path.unlink(missing_ok=True) + outcome = _rewrite_usage_log_safely(_tick) + except Exception as exc: # the service refuses rather than writes unsafely return {'status': 'unavailable', 'feature': feature, 'reason': str(exc)} + if outcome.get('status') == 'unchanged': + return {'status': 'already_marked', 'feature': feature, 'label': label} return {'status': 'marked', 'feature': feature, 'label': label} @@ -657,40 +681,42 @@ def fire_event( def update_consent(decision: str): - """ - Update usage_log.md with consent decision. - + """Record a consent decision in usage_log.md. + + Goes through the same lifecycle operation as a feature tick. That is what + makes the concurrency guarantee real: two direct writers to one file can + each read, modify and write a whole file and silently lose the other's + change, and consent is the half you least want to lose. + Args: decision: 'opted-in' or 'opted-out' """ - usage_path = get_vault_path() / 'System' / 'usage_log.md' - if not usage_path.exists(): - return - - with open(usage_path, 'r') as f: - content = f.read() - today = datetime.now().strftime('%Y-%m-%d') - - # Update consent fields - content = re.sub( - r'\*\*Consent asked:\*\* \w+', - '**Consent asked:** true', - content - ) - content = re.sub( - r'\*\*Consent decision:\*\* [\w-]+', - f'**Consent decision:** {decision}', - content - ) - content = re.sub( - r'\*\*Consent date:\*\* .+', - f'**Consent date:** {today}', - content - ) - - with open(usage_path, 'w') as f: - f.write(content) + + def _apply(current: str) -> Optional[str]: + updated = re.sub( + r'\*\*Consent asked:\*\* \w+', + '**Consent asked:** true', + current, + ) + updated = re.sub( + r'\*\*Consent decision:\*\* [\w-]+', + f'**Consent decision:** {decision}', + updated, + ) + updated = re.sub( + r'\*\*Consent date:\*\* .+', + f'**Consent date:** {today}', + updated, + ) + return updated + + try: + _rewrite_usage_log_safely(_apply) + except Exception: + # Preserve the prior contract: this returned silently when the log was + # missing or unwritable, and callers do not check a result. + return # Event name constants for consistency diff --git a/core/portable_contract.py b/core/portable_contract.py index 620a2efff..a777cef81 100644 --- a/core/portable_contract.py +++ b/core/portable_contract.py @@ -43,6 +43,12 @@ VAULT_SCHEMA_SUPPORTED = ">=1 <2" ANALYTICS_ATTEMPT_RECEIPT_RELATIVE = "System/.dex/analytics-attempts.jsonl" AUTOMATION_OWNERSHIP_RELATIVE = "System/.dex/automation-ownership.json" +# The adoption log is a runtime file that two callers mutate: feature ticks and +# consent decisions. Both go through one service operation so a concurrent pair +# cannot lose a whole-file change. The cap is generous against a shipped starter +# of a few kilobytes and still bounds the transaction read. +USAGE_LOG_RELATIVE = "System/usage_log.md" +USAGE_LOG_TRANSACTION_MAX_BYTES = 256 * 1024 AUTOMATION_OWNERSHIP_TRANSACTION_MAX_BYTES = 64 * 1024 # A receipt retains a bounded rolling history. A prior release could write one # safe record beyond the retained cap, so the transaction has exactly that @@ -661,6 +667,7 @@ def update_write_verdict( "conflict-resolution", "adoption-rewind", "release-anchor", + "usage-log", ): raise ValueError(f"unknown write operation: {operation}") @@ -870,6 +877,43 @@ def update_write_verdict( resolution.rule_id if resolution is not None else None, ) + if operation == "usage-log": + # Deliberately as narrow as the receipt rule: this operation exists so + # feature ticks and consent decisions share one guarded writer, and it + # may touch exactly one path. + try: + denied = is_denied(path) + candidate = _normalize(path) + except ContractViolation: + return WriteVerdict(str(path), False, "outside-usage-log", None, None) + try: + resolution = resolve(candidate) + except ContractViolation: + resolution = None + if denied: + return WriteVerdict( + candidate, + False, + "deny", + resolution.ownership if resolution is not None else None, + resolution.rule_id if resolution is not None else None, + ) + if candidate == USAGE_LOG_RELATIVE: + return WriteVerdict( + candidate, + True, + "write-usage-log", + resolution.ownership if resolution is not None else None, + resolution.rule_id if resolution is not None else None, + ) + return WriteVerdict( + candidate, + False, + "outside-usage-log", + resolution.ownership if resolution is not None else None, + resolution.rule_id if resolution is not None else None, + ) + if operation == "analytics-receipt": try: denied = is_denied(path) diff --git a/core/tests/test_usage_tracking.py b/core/tests/test_usage_tracking.py index 1d0f5651d..f21f5821e 100644 --- a/core/tests/test_usage_tracking.py +++ b/core/tests/test_usage_tracking.py @@ -205,3 +205,148 @@ def test_the_registered_tool_reports_an_unknown_feature_rather_than_failing(vaul ) assert payload["status"] == "not_found" + + +# --- the safety properties the direct write did not have --- +# +# Requested in review of #590. Each of these fails against a plain +# write_text + os.replace, which is what this file used to do. + + +def test_a_symlinked_system_directory_cannot_redirect_the_write( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + """A vault whose System directory is a symlink must not write outside it. + + The direct implementation resolved the path through the symlink and wrote + to the target, which puts a vault mutation anywhere the link points. + """ + outside = tmp_path / "outside" + outside.mkdir() + (outside / "usage_log.md").write_text(LOG_WITH_CONSENT, encoding="utf-8") + before = (outside / "usage_log.md").read_text(encoding="utf-8") + + vault = tmp_path / "vault" + vault.mkdir() + (vault / "System").symlink_to(outside, target_is_directory=True) + monkeypatch.setenv("VAULT_PATH", str(vault)) + + result = analytics_helper.mark_feature_used("meeting-prep") + + assert result["status"] == "unavailable" + assert (outside / "usage_log.md").read_text(encoding="utf-8") == before + + +def test_a_symlinked_log_file_is_refused( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + outside = tmp_path / "elsewhere.md" + outside.write_text(LOG_WITH_CONSENT, encoding="utf-8") + before = outside.read_text(encoding="utf-8") + + vault = tmp_path / "vault" + (vault / "System").mkdir(parents=True) + (vault / "System" / "usage_log.md").symlink_to(outside) + monkeypatch.setenv("VAULT_PATH", str(vault)) + + result = analytics_helper.mark_feature_used("meeting-prep") + + assert result["status"] == "unavailable" + assert outside.read_text(encoding="utf-8") == before + + +def test_a_tightened_file_mode_survives_a_write(vault: Path) -> None: + """A 0600 log must not become 0644 because the umask said so. + + write_text on a fresh temporary file takes the process umask, and a rename + over the original carries that mode with it. The plan re-states the mode. + """ + log = vault / "System" / "usage_log.md" + log.chmod(0o600) + + assert analytics_helper.mark_feature_used("meeting-prep")["status"] == "marked" + + assert log.stat().st_mode & 0o777 == 0o600 + + +def test_an_unusual_but_legitimate_mode_is_also_preserved(vault: Path) -> None: + log = vault / "System" / "usage_log.md" + log.chmod(0o640) + + analytics_helper.mark_feature_used("meeting-prep") + + assert log.stat().st_mode & 0o777 == 0o640 + + +def test_a_feature_tick_and_a_consent_update_do_not_lose_each_other( + vault: Path, +) -> None: + """The race the fixed .tmp sibling allowed, driven deterministically. + + Both mutators used to read the whole file, modify it, and write it back. + Interleaved, the second writer's copy is built from pre-first-writer text, + so one whole-file change disappears. Here the consent update lands from + inside the feature tick's transform, which is exactly that interleaving. + """ + log = vault / "System" / "usage_log.md" + original_rewrite = analytics_helper._rewrite_usage_log_safely + fired: list[str] = [] + + def racing_rewrite(transform): + def wrapped(current: str): + if not fired: + fired.append("consent") + analytics_helper.update_consent("opted-out") + return transform(current) + + return original_rewrite(wrapped) + + analytics_helper._rewrite_usage_log_safely = racing_rewrite + try: + result = analytics_helper.mark_feature_used("meeting-prep") + finally: + analytics_helper._rewrite_usage_log_safely = original_rewrite + + updated = log.read_text(encoding="utf-8") + + assert fired == ["consent"] + assert result["status"] == "marked" + # Neither change was lost: the tick landed AND the consent decision stuck. + assert "- [x] Meeting prep (`/meeting-prep`)" in updated + assert "**Consent decision:** opted-out" in updated + + +def test_consent_updates_also_go_through_the_guarded_writer( + vault: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + """Dave's point: the guarantee is only real if both mutators use one door.""" + seen: list[str] = [] + original = analytics_helper._rewrite_usage_log_safely + + def recording(transform): + seen.append("used") + return original(transform) + + monkeypatch.setattr(analytics_helper, "_rewrite_usage_log_safely", recording) + + analytics_helper.update_consent("opted-out") + + assert seen == ["used"] + assert analytics_helper.check_consent() == "opted-out" + + +def test_the_operation_may_write_only_the_usage_log() -> None: + """The contract, not the caller, is what bounds this operation.""" + from core import portable_contract + + allowed = portable_contract.update_write_verdict( + portable_contract.USAGE_LOG_RELATIVE, exists=True, operation="usage-log" + ) + refused = portable_contract.update_write_verdict( + "03-Tasks/Tasks.md", exists=True, operation="usage-log" + ) + + assert allowed.allowed is True + assert allowed.action == "write-usage-log" + assert refused.allowed is False + assert refused.action == "outside-usage-log" diff --git a/core/transaction/engine.py b/core/transaction/engine.py index e4aade0c2..03b94c2a9 100644 --- a/core/transaction/engine.py +++ b/core/transaction/engine.py @@ -182,6 +182,12 @@ def _begin_with_id( portable_contract.ANALYTICS_ATTEMPT_RECEIPT_TRANSACTION_MAX_BYTES ) } + elif operation == "usage-log": + required_limit = { + portable_contract.USAGE_LOG_RELATIVE: ( + portable_contract.USAGE_LOG_TRANSACTION_MAX_BYTES + ) + } elif operation == "automation-ownership": required_limit = { portable_contract.AUTOMATION_OWNERSHIP_RELATIVE: ( @@ -833,6 +839,12 @@ def _read_limits_from_begin_payload(payload: dict) -> dict[str, int]: portable_contract.ANALYTICS_ATTEMPT_RECEIPT_TRANSACTION_MAX_BYTES ) } + elif operation == "usage-log": + required_limit = { + portable_contract.USAGE_LOG_RELATIVE: ( + portable_contract.USAGE_LOG_TRANSACTION_MAX_BYTES + ) + } elif operation == "automation-ownership": required_limit = { portable_contract.AUTOMATION_OWNERSHIP_RELATIVE: ( From 3a2e6100ccd04be78ece2f703751fdbb3447251f Mon Sep 17 00:00:00 2001 From: Chris Jackson <201591867+chrisjackson-coding@users.noreply.github.com> Date: Wed, 26 Aug 2026 10:29:16 +0100 Subject: [PATCH 3/7] Account for the new tool in the capability catalogue Making mark_feature_used reachable adds a fifth tool to dex-analytics, which the capability discovery added in v1.97.0 pins exactly: the boundary test asserted 131 tools and 4 on this server, and the committed enriched example listed the old four by name. Updated both, and renamed the test so its name still matches what it asserts. The example is regenerated output, not a hand edit; the only difference is the new tool appearing in the count, the summary sentence and the example list. Co-Authored-By: Claude Opus 5 Co-authored-by: davekilleen --- core/tests/test_dex_lens_catalog_generation.py | 2 +- core/tests/test_lens_catalog_enriched_discovery.py | 4 ++-- docs/architecture/INVENTORY.md | 4 ++-- docs/examples/dex-lens-catalog-enriched-preview.json | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/core/tests/test_dex_lens_catalog_generation.py b/core/tests/test_dex_lens_catalog_generation.py index 9fec6558c..2a0c41cd8 100644 --- a/core/tests/test_dex_lens_catalog_generation.py +++ b/core/tests/test_dex_lens_catalog_generation.py @@ -772,7 +772,7 @@ def test_corrected_catalogue_has_complete_truthful_identity_sets( assert "connect" not in by_id assert by_id["dex-pipedrive-mcp"]["tool_count"] == 15 assert by_id["connection-manager-engine"]["availability"] == "parked" - assert sum(entry.get("tool_count", 0) for entry in entries) == 156 + assert sum(entry.get("tool_count", 0) for entry in entries) == 157 def test_signed_enriched_release_path_carries_the_significant_family_contract( diff --git a/core/tests/test_lens_catalog_enriched_discovery.py b/core/tests/test_lens_catalog_enriched_discovery.py index ac1ac06ff..b5dc87840 100644 --- a/core/tests/test_lens_catalog_enriched_discovery.py +++ b/core/tests/test_lens_catalog_enriched_discovery.py @@ -42,9 +42,9 @@ def test_discovers_every_core_and_integration_mcp_server() -> None: servers = discover_mcp_servers(REPO_ROOT) assert len(servers) == 11 - assert sum(server.tool_count for server in servers) == 156 + assert sum(server.tool_count for server in servers) == 157 assert {server.server_name: server.tool_count for server in servers} == { - "dex-analytics": 4, + "dex-analytics": 5, "dex-calendar-mcp": 15, "dex-career-mcp": 8, "dex-customization-migration-mcp": 7, diff --git a/docs/architecture/INVENTORY.md b/docs/architecture/INVENTORY.md index dd47048e8..8f8d25e43 100644 --- a/docs/architecture/INVENTORY.md +++ b/docs/architecture/INVENTORY.md @@ -1,6 +1,6 @@ - + # Architecture Inventory @@ -12,7 +12,7 @@ This inventory is derived only from repository code and shipped skill files. | Server | Source | Tool count | `feature_status` honesty contract | Exposed tools | | --- | --- | ---: | :---: | --- | -| `dex-analytics` | `core/mcp/analytics_server.py` | 4 | yes | `check_analytics_status`, `identify_user`, `test_connection`, `track_event` | +| `dex-analytics` | `core/mcp/analytics_server.py` | 5 | yes | `check_analytics_status`, `identify_user`, `mark_feature_used`, `test_connection`, `track_event` | | `dex-calendar-mcp` | `core/mcp/calendar_server.py` | 15 | yes | `calendar_create_event`, `calendar_delete_event`, `calendar_get_events`, `calendar_get_events_with_attendees`, `calendar_get_next_event`, `calendar_get_today`, `calendar_list_calendars`, `calendar_search_events`, `reminders_clear_completed`, `reminders_complete_item`, `reminders_create_item`, `reminders_ensure_lists`, `reminders_find_and_complete`, `reminders_list_completed`, `reminders_list_items` | | `dex-career-mcp` | `core/mcp/career_server.py` | 8 | yes | `analyze_coverage`, `generate_evidence_from_work`, `parse_ladder`, `promotion_readiness_score`, `scan_evidence`, `scan_work_for_evidence`, `skills_gap_analysis`, `timeline_analysis` | | `dex-customization-migration-mcp` | `core/mcp/customization_migration_server.py` | 7 | yes | `assess_customizations`, `preview_customization_capsule`, `read_activation_status`, `read_customization_capsule_blob`, `read_customization_capsule_section`, `read_customization_migration_status`, `read_staging_status` | diff --git a/docs/examples/dex-lens-catalog-enriched-preview.json b/docs/examples/dex-lens-catalog-enriched-preview.json index a461146d6..582a7ee00 100644 --- a/docs/examples/dex-lens-catalog-enriched-preview.json +++ b/docs/examples/dex-lens-catalog-enriched-preview.json @@ -1 +1 @@ -{"catalogue":{"capabilities":[{"availability":"active","capability_class":"active-skill","capability_id":"apple-mail-setup","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/apple-mail-setup/SKILL.md","summary":"The shipped Apple Mail Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["capture-without-friction"],"portable_brief":{"goal":"Set up and verify Apple Mail search on macOS, including the search index that silently returns nothing when it was never built.","method_outline":["Inspect the current local state and the person's request.","Run the Apple Mail Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.96.3","summary":"Set up and verify Apple Mail search on macOS, including the search index that silently returns nothing when it was never built. Use when the user says 'connect Apple Mail', 'set up mail search', 'Dex can't find my emails', 'mail search returns nothing'. Not for Gmail or Google Workspace; use `google-workspace-setup`.","title":"Apple Mail Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Set up and verify Apple Mail search on macOS, including the search index that silently returns nothing when it was never built."},{"availability":"active","capability_class":"active-skill","capability_id":"atlassian-setup","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/atlassian-setup/SKILL.md","summary":"The shipped Atlassian Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Connect Jira and Confluence for project tracking and knowledge search.","method_outline":["Inspect the current local state and the person's request.","Run the Atlassian Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Connect Jira and Confluence for project tracking and knowledge search. Use when the user says 'connect Jira', 'hook up Confluence', 'my tickets/board'. Not for a personal task app like Todoist/Things/Trello; use `todoist-setup`/`things-setup`/`trello-setup`.","title":"Atlassian Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Jira and Confluence for project tracking and knowledge search."},{"availability":"active","capability_class":"active-skill","capability_id":"backup-now","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","honest-health-observability","ownership-portability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["local-file-access","off-machine-destination"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"verified","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_backup_vault.py","summary":"Real behaviour coverage of a single run: a successful run stores the set and records it, a failure records the actual error rather than a generic one, and a run that fails part-way leaves no half-written copy behind to be mistaken for a good one."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/backup-now/SKILL.md","summary":"The shipped skill defines the on-demand run, the rule against inferring success from the command finishing, and the quiet note when the last successful copy is old."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Take a verified copy on demand before a risky change, and report the recorded result rather than the command's exit.","method_outline":["Run the same copying path the schedule uses; do not build a second one.","Read the run record afterwards and report what it says.","On failure, repeat the recorded reason exactly rather than softening it.","Mention quietly when the previous successful copy is old."],"rollback_advice":"Delete the copy that was just made; on-demand runs add a copy and never change the live material.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["A failed run is never reported as a copy that exists.","The reported size and destination come from the record, not the intent.","A run with no configured destination fails clearly instead of guessing one."]},"prerequisites":["Backups already configured; without a destination the run fails with a plain message rather than improvising one.","A minute or so, and room at the destination."],"release_provenance":"core-release","since_release":"1.95.1","summary":"Run a vault backup right now and report the verified result. Use when the user says 'back up now', 'take a backup before I do this', or is about to make a big change. Not for scheduling or changing where backups go (`backup-setup`); not for getting files back (`backup-restore`).","title":"Backup Now","trade_offs":["An on-demand copy covers one moment and is not a substitute for a schedule.","Success is read from the run record rather than from the command exiting, so a partial copy is reported as a failure."],"value":"Takes a copy right now, before a bulk edit or a migration, and reports what actually landed rather than treating a finished command as a success."},{"availability":"active","capability_class":"active-skill","capability_id":"backup-restore","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","ownership-portability","honest-health-observability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["local-file-access","off-machine-destination"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"verified","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_backup_vault.py","summary":"Real behaviour coverage of all three modes: verification passes on an intact copy and detects a damaged one, the test mode unpacks only into a temporary folder, a real restore refuses the live location and any folder that is not empty, and a damaged newest copy points at the newest intact one instead."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"doc: docs/backup-restore.md","summary":"The shipped recovery guide covers what a full rebuild needs beyond the copies, including the credentials and schedules deliberately left out of them."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/backup-restore/SKILL.md","summary":"The shipped skill defines the three modes, the routine test restore, and the rule to report exactly what the tool printed rather than a reassuring summary."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Prove a backup restores, and perform a real restore without ever writing over the live material.","method_outline":["Check the copy's fingerprints and history before trusting it.","Offer a routine test that unpacks into a throwaway folder and then deletes it.","For a real restore, require a new or empty destination and refuse the live one.","State plainly what is not in the copy and must be re-established by hand."],"rollback_advice":"Delete the folder the restore was written into; because a restore never targets the live location, removing that folder returns the system to its prior state.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["A deliberately damaged copy is detected rather than restored.","The live material is provably untouched after a restore.","A failed verification is reported as failure, with the next intact copy named."]},"prerequisites":["At least one completed copy to check.","A new or empty folder to restore into when a real recovery is wanted."],"release_provenance":"core-release","since_release":"1.95.1","summary":"Verify a vault backup, prove it restores, or restore it to a folder of the user's choosing. Use when the user says 'restore my backup', 'test my backups', 'are my backups any good', or after data loss. Never overwrites the live vault. Not for taking a backup (`backup-now`); not for scheduling (`backup-setup`).","title":"Backup Restore","trade_offs":["A restore never overwrites the live material, so moving it back into place stays a deliberate human step.","Where a copy is damaged it says so and points at the next intact one rather than pretending the newest is usable."],"value":"Proves the copies actually come back — fingerprints checked, the whole thing unpacked into a scratch folder — and, when a real recovery is needed, puts it somewhere new instead of over the live work."},{"availability":"active","capability_class":"active-skill","capability_id":"backup-setup","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","ownership-portability","honest-health-observability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["local-file-access","off-machine-destination","scheduler"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"verified","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_backup_vault.py","summary":"Real behaviour coverage of the copying engine and its scheduler: the ladder of older copies keeps what it claims and never deletes the newest one, a real sign-in token never reaches the archive, an ordinary note that merely looks secret is still kept, and on a system without the supported scheduler nothing is installed and the equivalent instruction is printed instead."},{"level":"verified","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_doctor.py","summary":"The health check's backup probe is covered directly: a recent, successful run that quietly stored less than a full copy is reported as broken rather than passing as fine."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"doc: docs/backup-restore.md","summary":"The shipped recovery guide states what a full rebuild needs beyond the copies themselves, including the things deliberately excluded from them."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/backup-setup/SKILL.md","summary":"The shipped skill defines the destination choice, the retention ladder, the scheduling step, and the rule that setup is not reported as done until a real run has succeeded."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Set up scheduled, verified copies of the person's whole working record, kept somewhere other than the machine that made them.","method_outline":["Choose a destination off the machine, and never write credentials into it.","Exclude keys, tokens and caches from the copy on purpose, and say what was excluded.","Keep a ladder of recent and older copies, and never delete the newest one.","Prove it by running one for real before calling the setup finished.","Add a health check that treats a stale copy as a problem, not a warning."],"rollback_advice":"Remove the scheduled job and the backup settings; existing copies stay where they are and the person's live material is never touched by the setup.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["A real credential file is provably absent from the copy.","The newest copy survives even a retention rule that would delete everything.","A run that failed is reported as failed, with the recorded reason."]},"prerequisites":["A synced folder or a cloud storage account for the copies to go to.","Automatic scheduling is wired up for macOS; on other systems the person is given the exact line to schedule it themselves, and nothing is installed behind their back."],"release_provenance":"core-release","since_release":"1.95.1","summary":"Set up automatic vault backups to a synced folder or a cloud provider, with verified archives and tiered retention. Use when the user says 'back up my vault', 'set up backups', 'where are my backups going', or asks about losing their notes. Not for restoring or testing a restore (`backup-restore`); not for a one-off backup right now (`backup-now`).","title":"Backup Setup","trade_offs":["Keys and sign-in tokens are deliberately left out of the copies, so rebuilding on a new machine means entering those again.","A backup that has never been test-restored is still only a hope, which is why proving the restore is a separate step."],"value":"Puts the person's whole working record on a schedule that copies it somewhere else, keeps a ladder of older copies, and says so loudly when it quietly stops working."},{"availability":"active","capability_class":"active-skill","capability_id":"calendar-setup","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/calendar-setup/SKILL.md","summary":"The shipped Calendar Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["start-each-day-focused"],"portable_brief":{"goal":"Grant Python calendar access for ~30x faster calendar queries.","method_outline":["Inspect the current local state and the person's request.","Run the Calendar Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Grant Python calendar access for ~30x faster calendar queries. Use when the user says 'connect my calendar', 'calendar is slow', 'set up calendar access'. Not for connecting Google Workspace as a whole; use `google-workspace-setup`.","title":"Calendar Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Grant Python calendar access for ~30x faster calendar queries."},{"availability":"active","capability_class":"active-skill","capability_id":"change-job","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","scoped-agency-human-control","durable-memory-provenance"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory","durable-goals-or-tasks","task-or-note-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_instruction_honesty.py","summary":"Pins the transition's load-bearing promises: the settings after-check is relayed word for word, a failed check stops every later pass, nothing is deleted, each project is its own question, and connections are listed for review, never removed. The tests read the shipped instructions."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_transition_capsule.py","summary":"Covers the snapshot-and-verify lane the transition relies on: the pre-change capture, the after-check that names lost or unexpected changes, and the exact restore of the two settings files."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/change-job/SKILL.md","summary":"The shipped skill defines the five passes, the rule that every pass is previewed, confirmed and skippable, and the closing ledger naming what changed and how to undo each step."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Guide a job or role transition where every pass is previewed, confirmed, skippable, and undoable, and the settings that were not re-answered provably carry forward.","method_outline":["Lay out the five passes in plain words and get a yes before starting.","Re-run setup with carry-forward; relay the after-check and stop everything if it fails.","Re-sort people from their recorded emails, plan shown first, never guessing.","Archive the old role's planning whole and walk projects one at a time.","Re-point open tasks at the new pillars and hand grooming to the backlog skill."],"rollback_advice":"The settings snapshot restores the two configuration files exactly as captured; archived pages move back from the dated role-transition folder; the people re-sort reverses by running it against the old domain.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["A failed settings check stops the transition before any later pass runs.","Nothing is deleted; every exit is archive, park, or leave alone.","The closing ledger names each pass done or skipped and how to undo it."]},"prerequisites":["A vault that completed first-time setup.","The new role's work email domain, so people can be re-sorted."],"release_provenance":"core-release","since_release":"1.97.7","summary":"Guided job or role transition: re-run the setup questions with every unanswered setting carried forward and checked afterwards, re-sort people for the new work email domain, archive the old role's goals, priorities and projects (never deleted), re-point open tasks at the new pillars, and close with a ledger of what changed and how to undo each step. Use when the user says 'I changed jobs', 'I'm changing jobs', 'new role', 'new job', 'went full-time', or 'I'm now [role] at [company]'. Not for a preference change within the same job; use `reset`. Not for first-time setup; use `setup`.","title":"Change Job","trade_offs":["The setup questions are asked again in full, even when only a few answers changed.","People with no recorded email are left where they are rather than guessed, so a few pages may still need moving by hand."],"value":"Moves a whole Dex from one job to the next without losing anything: setup answers carried forward and checked against a snapshot, people re-sorted for the new work email, the old role's planning archived rather than deleted, and open tasks re-pointed at the new pillars."},{"availability":"active","capability_class":"active-skill","capability_id":"commitments","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","meeting-source","task-or-note-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_commitments_skill.py","summary":"Dedicated tests pin the load-bearing promises: it reuses the existing scanner rather than building a second one, never creates a task without confirmation, says so plainly when the scan is unavailable instead of inventing a list, and reads back what it created before reporting. The tests read the shipped instructions, not a live scan."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/commitments/SKILL.md","summary":"The shipped skill defines the present-then-confirm flow, the split between promises made and asks received, and the refusal to pad an empty result."}],"impact_tier":"core","jobs":["manage-tasks-reliably"],"portable_brief":{"goal":"Create a review that surfaces open promises and asks from existing records and tracks only the ones the person confirms.","method_outline":["Read the existing commitment sources rather than building a second store.","Drop anything already tracked, and group the rest by who owes whom.","Put genuinely ambiguous items in an unclear group instead of guessing direction.","Offer each item for confirmation, then read back exactly what was created."],"rollback_advice":"Delete the tasks the review created; the meetings and notes it read from are never modified, so the source record is unaffected.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["An empty result is reported as empty, not padded with vague follow-ups.","No item becomes tracked work without an explicit yes.","Every item reported as captured has a real identifier behind it."]},"prerequisites":["Meeting notes or people records the scan can read.","A task list the confirmed commitments can become."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Reconcile the promises you made and the asks you received across meetings and notes into a clear owner/due/source list, then — only with your confirmation — turn the real ones into tracked tasks. Use when the user says 'what did I promise', 'what am I on the hook for', 'anything I owe people', 'loose ends', or after a run of meetings. Also use proactively during daily-plan/daily-review when uncaptured commitments surface. Not for tracking work you handed off to others; use `delegate-check`. Not for recording a decision you made; use `decision-log`.","title":"Commitments","trade_offs":["Which direction a promise runs is inferred from wording, so genuinely unclear items are shown as unclear rather than guessed.","Nothing becomes tracked without item-by-item confirmation, which costs the person a little attention each time."],"value":"Pulls the small promises — “I’ll send that over”, “can you review this” — out of meetings and notes into one list of who owes what, and tracks only the ones the person confirms are real."},{"availability":"active","capability_class":"active-skill","capability_id":"create-mcp","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/create-mcp/SKILL.md","summary":"The shipped Create Mcp skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Build a brand-new MCP integration from scratch with a guided wizard.","method_outline":["Inspect the current local state and the person's request.","Run the Create Mcp workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Build a brand-new MCP integration from scratch with a guided wizard. Use when the user wants Dex to talk to a tool that has no existing server — 'build an integration for X', 'Dex can't connect to Y yet'. Not for installing an MCP that already exists; use `integrate-mcp`. Not for a prompt-only workflow with no external tool; use `create-skill`.","title":"Create Mcp","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Build a brand-new MCP integration from scratch with a guided wizard."},{"availability":"active","capability_class":"active-skill","capability_id":"create-skill","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/create-skill/SKILL.md","summary":"The shipped Create Skill skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Author a new Dex skill.","method_outline":["Inspect the current local state and the person's request.","Run the Create Skill workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Author a new Dex skill — a reusable `/command` — that actually fires and passes the quality bar. Runs a collision check, classifies the shape, writes a router-grade description, generates the real package (SKILL.md + evals), and grades it with `skill-score` before calling it done. Use when the user says 'make a skill', 'I want a /command for X', 'turn this into a skill'. A skill the user builds for themselves is saved under `.claude/skills-custom/` (protected from updates) and coached, never blocked; a first-party skill is held to the hard gate. Not for connecting an external tool; use `create-mcp`. Not for grading a skill that already exists; use `skill-score`.","title":"Create Skill","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Author a new Dex skill."},{"availability":"active","capability_class":"active-skill","capability_id":"daily-plan","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","readable-task-source"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_commitments_skill.py","summary":"The planning path is covered where commitments become bounded, reviewable tasks."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/daily-plan/SKILL.md","summary":"The shipped skill defines the daily planning workflow and its required source checks."}],"impact_tier":"core","jobs":["start-each-day-focused"],"portable_brief":{"goal":"Create a daily planning routine that combines meetings, tasks and commitments into one bounded plan.","method_outline":["Read current commitments and calendar shape.","Choose a short list that fits the available time.","Keep any task creation reviewable by the person."],"rollback_advice":"Disable or remove the planning command; the workflow should not require irreversible data changes.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The output names a realistic number of actions for today.","The person can reject or edit task changes before anything persists."]},"prerequisites":["A readable task list or commitment source.","Calendar access improves the plan but is not the only input."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Build today's plan from calendar, tasks, priorities and commitments, with smart scheduling suggestions. Use when the user says 'plan my day', 'what's on today', 'help me focus', or starts the morning. Also use proactively at the first session of the day. Not for reviewing a finished day; use `daily-review`.","title":"Daily Plan","trade_offs":["The plan is only as current as the sources it can inspect.","It drafts priorities; the person still chooses what to do."],"value":"Helps a person choose a small, realistic focus list before the day scatters across meetings, tasks and loose commitments."},{"availability":"active","capability_class":"active-skill","capability_id":"daily-review","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","readable-task-source","durable-memory-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_review_retirement.py","summary":"A dedicated test pins the end-of-day behaviour Dex ships: the review runs in the current conversation, and where a review already exists for today it checks that one rather than writing a competing second version. It reads the shipped instructions, not a live day."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_skill_delegated_gathering.py","summary":"Covers the paired gathering instructions this review depends on for a large collection of notes, so the heavy reading step cannot be silently orphaned by a later edit."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/daily-review/SKILL.md","summary":"The shipped skill defines the end-of-day workflow, the check against an existing review, and the confirmation rules before anything is written."}],"impact_tier":"high","jobs":["start-each-day-focused","reflect-and-improve-continuously"],"portable_brief":{"goal":"Create an end-of-day routine that compares intention with what actually happened and sets one starting point for tomorrow.","method_outline":["Read the day's plan, completed work and any meeting record the person approved.","Name what was finished, what slipped and what a meeting left owing.","Check whether a review already exists for today and correct it rather than duplicating it.","Agree one starting point for tomorrow with the person before writing anything."],"rollback_advice":"Stop running the routine and delete the generated review files; the underlying tasks, notes and meeting records are never rewritten by it, so they need no undo.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The review distinguishes finished work from work that merely moved.","A second run on the same day does not create a competing record.","Nothing is written to the person's own material without their confirmation."]},"prerequisites":["Today's plan, tasks or notes in a place the system can read.","A few minutes with the person; the review asks questions it cannot answer for them."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Close out the day: what got done vs planned, meeting follow-ups, learnings, and tomorrow's focus. Use when the user says 'review my day', 'wrap up', 'end of day', or it's evening. Also use proactively when the day's work is clearly done. Not for setting up the morning; use `daily-plan`.","title":"Daily Review","trade_offs":["A review can only see the parts of the day that were written down somewhere.","It proposes tomorrow's focus and any change to the record; the person confirms both."],"value":"Closes the day the morning plan opened: what actually got done against what was intended, what a meeting left behind, and what tomorrow starts with — so the loop finishes instead of drifting."},{"availability":"active","capability_class":"active-skill","capability_id":"decision-log","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability","context-orientation"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-memory-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_adoption_effective_behavior.py","summary":"Real behaviour coverage of how this capability is switched on and off again: the test adopts it through Dex's live change system, proves the change can be rewound exactly, and proves a rewind refuses rather than overwrite a file the person has since edited. That covers the switch-on path, not the recording conversation itself."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/decision-log/SKILL.md","summary":"The shipped skill defines what a decision record must contain, where it is filed, and the rule that earlier entries are never rewritten to make history look cleaner."}],"impact_tier":"high","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Create a decision record that captures the choice, the real alternatives, the reasoning and when to revisit it.","method_outline":["Search for an earlier decision on the same topic before recording a new one.","Capture the choice, what made it necessary, the options considered and why this one won.","Set a review date, or state plainly that no review is needed.","File it in the narrowest useful place and confirm where it went."],"rollback_advice":"Delete the appended decision entry; earlier entries are never modified, so removing the new one restores the previous state exactly.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The record contains no option or reason the person did not actually give.","An earlier decision it replaces is linked rather than overwritten.","Dates are absolute, so the record still reads correctly years later."]},"prerequisites":["A home for decisions that is separate from the meeting they came out of.","The person's own account of the options; the record never supplies reasoning they did not give."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Capture an important decision with its context, options, rationale, and review date, then find it again when it matters.","title":"Decision Log","trade_offs":["A decision record earns its keep only if it can be found again, which depends on where it is filed.","A superseded decision is added as a new entry rather than edited, so the history grows rather than tidies."],"value":"Keeps the reason behind a choice — the options, the rationale, the date to look at it again — so nobody has to reconstruct it from memory months later."},{"availability":"active","capability_class":"active-skill","capability_id":"delegate-check","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","task-or-note-store","relationship-history"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_adoption_effective_behavior.py","summary":"Real behaviour coverage of how this capability is switched on and off again: the test adopts it through Dex's live change system, proves the change can be rewound exactly, and proves a rewind refuses rather than overwrite a file the person has since edited. That covers the switch-on path, not the review conversation itself."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/delegate-check/SKILL.md","summary":"The shipped skill defines what counts as an open handoff, the order attention is spent in, and the rule that no message is sent and no record changed without approval."}],"impact_tier":"high","jobs":["manage-tasks-reliably"],"portable_brief":{"goal":"Create a delegation review that separates moving work from stuck work and proposes one proportionate follow-up.","method_outline":["Collect open handoffs from tasks and recent meeting notes, and merge duplicates.","For each, record what, who, when it was handed over, what is expected and when.","Order the review by what needs attention, keeping healthy items brief.","Draft one short nudge per stuck item and send nothing without approval."],"rollback_advice":"Stop running the review and discard its drafts; it changes a record only after the person confirms, so nothing needs to be undone on their behalf.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Silence is reported as unclear status, never as progress or failure.","Conflicting records are shown as a conflict rather than resolved silently.","No message leaves and no status changes without an explicit yes."]},"prerequisites":["Tasks or meeting notes that record who owns what.","The person's approval before any nudge is sent or any status is changed."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Review open delegations — what you handed off, to whom, its status, and the next useful nudge. Use when the user says 'what did I delegate', 'who owes me', 'check my handoffs', 'follow up with someone'. Not for prepping a meeting; use meeting-prep.","title":"Delegate Check","trade_offs":["Where two records disagree about status, it shows the disagreement instead of quietly picking one.","It will not chase a handoff whose agreed date has not arrived, so a genuinely early risk can still be missed."],"value":"Shows what was handed to other people, what is moving, what is stuck and the one short nudge worth sending — and reports silence as unknown rather than as progress."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-add-mcp","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-add-mcp/SKILL.md","summary":"The shipped Dex Add Mcp skill defines the workflow Lens is cataloguing."}],"impact_tier":"medium","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Add a known MCP server to config using Dex-safe user scope.","method_outline":["Inspect the current local state and the person's request.","Run the Dex Add Mcp workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Add a known MCP server to config using Dex-safe user scope. Use when the user has server details in hand and says 'add this MCP', 'register this server'. Not for discovering/installing from a marketplace; use `integrate-mcp`. Not for building one; use `create-mcp`.","title":"Dex Add Mcp","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Add a known MCP server to config using Dex-safe user scope."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-backlog","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-backlog/SKILL.md","summary":"The shipped Dex Backlog skill defines the workflow Lens is cataloguing."}],"impact_tier":"medium","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Show the AI-ranked backlog of Dex system-improvement ideas.","method_outline":["Inspect the current local state and the person's request.","Run the Dex Backlog workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Show the AI-ranked backlog of Dex system-improvement ideas. Use when the user says 'show my Dex ideas', 'what's in the backlog', 'what should we build next'. Not for workshopping one idea into a plan; use `dex-improve`. Not for discovering existing features; use `dex-level-up`.","title":"Dex Backlog","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Show the AI-ranked backlog of Dex system-improvement ideas."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-doctor","changed_in":[],"compatibility":{"foundation_capabilities":["honest-health-observability","safe-change-recovery","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["local-diagnostics","feature-status-vocabulary"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"verified","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_doctor.py","summary":"Doctor behavior is covered by the main health-check test suite."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-doctor/SKILL.md","summary":"The shipped skill defines the checkup flow and safe repair boundary."}],"impact_tier":"core","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Create a local health check that distinguishes working, off, broken and unknown states without over-claiming.","method_outline":["Probe the same paths the real features use.","Report unknown when evidence is incomplete.","Keep any repair action behind a separate approval path."],"rollback_advice":"Disable repair actions first; the diagnostic report can remain read-only.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["A sabotaged probe does not become working.","Unknown and off states are visible to the person.","No secret value appears in output."]},"prerequisites":["A host can run local checks against its own configuration.","Repair paths must be separately gated from diagnosis."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Whole-system checkup: verifies every Dex feature honestly (working/off/broken/couldn't-check), self-heals what's provably safe, guides the rest. Use when the user says 'is Dex healthy', 'something's broken', 'check my setup', 'run diagnostics'. Not for discovering unused *features*; use `dex-level-up`. Not for applying an update; use `dex-update`.","title":"Dex Doctor","trade_offs":["A check can report unknown when evidence is missing.","Automatic repair must remain limited to provably safe fixes."],"value":"Gives the person an honest system check: what works, what is off, what is broken and what should not be guessed."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-improve","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-improve/SKILL.md","summary":"The shipped Dex Improve skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Workshop one improvement idea into an implementation plan.","method_outline":["Inspect the current local state and the person's request.","Run the Dex Improve workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Workshop one improvement idea into an implementation plan. Use when the user says 'let's flesh out idea-X', 'turn this into a plan', 'improve Dex's Y'. Not for ranking the whole backlog; use `dex-backlog`. Not for a PRD for the user's own product; use `product-brief`.","title":"Dex Improve","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Workshop one improvement idea into an implementation plan."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-level-up","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-level-up/SKILL.md","summary":"The shipped Dex Level Up skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Surface Dex features the user isn't using yet, based on their usage patterns.","method_outline":["Inspect the current local state and the person's request.","Run the Dex Level Up workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Surface Dex features the user isn't using yet, based on their usage patterns. Use when the user says 'what am I missing', 'show me new features', 'level up my Dex'. Not for diagnosing what's broken; use `dex-doctor`. Not for what changed in a release; use `dex-whats-new`.","title":"Dex Level Up","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Surface Dex features the user isn't using yet, based on their usage patterns."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-obsidian-setup","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-obsidian-setup/SKILL.md","summary":"The shipped Dex Obsidian Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"medium","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Turn on Obsidian mode and migrate the vault to wiki links.","method_outline":["Inspect the current local state and the person's request.","Run the Dex Obsidian Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Turn on Obsidian mode and migrate the vault to wiki links. Use when the user says 'I use Obsidian', 'enable wiki links', 'make this work in Obsidian'. Not for connecting an external tool/API; use `create-mcp`/`integrate-mcp`.","title":"Dex Obsidian Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Turn on Obsidian mode and migrate the vault to wiki links."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-orient","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-orient/SKILL.md","summary":"The shipped Dex Orient skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Orient a Dex Core contributor in release truth, local changes and the canonical architecture maps.","method_outline":["Inspect the current local state and the person's request.","Run the Dex Orient workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.69.0","summary":"Orient in the Dex Core codebase: prints the released version, what's merged-but-not-released, and where the architecture map + inventory live. Use at the start of any dex-core development or investigation, or whenever you're unsure what's shipped vs built-locally vs prototype.","title":"Dex Orient","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Orient in the Dex Core codebase: prints the released version, what's merged-but-not-released, and where the architecture map + inventory live. Use at the start of any dex-core development or investigation, or whenever you're unsure what's shipped vs built-locally vs prototype."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-rollback","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-rollback/SKILL.md","summary":"The shipped Dex Rollback skill defines the workflow Lens is cataloguing."}],"impact_tier":"core","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Rewind one receipt-backed Dex adoption through the frozen lifecycle service.","method_outline":["Inspect the current local state and the person's request.","Run the Dex Rollback workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Rewind one receipt-backed Dex adoption through the frozen lifecycle service. Use when the user says 'undo the update', 'go back', 'that broke something after updating'. Not for applying an update; use `dex-update`.","title":"Dex Rollback","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Rewind one receipt-backed Dex adoption through the frozen lifecycle service."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-update","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-update/SKILL.md","summary":"The shipped Dex Update skill defines the workflow Lens is cataloguing."}],"impact_tier":"core","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Preview and safely adopt a Dex update through the receipt-backed lifecycle (look → back up → apply → verify → rewindable).","method_outline":["Inspect the current local state and the person's request.","Run the Dex Update workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Preview and safely adopt a Dex update through the receipt-backed lifecycle (look → back up → apply → verify → rewindable). Use when the user says 'update Dex', 'install the new version', or a release notice appeared. Not for undoing an update; use `dex-rollback`. Not just seeing what changed; use `dex-whats-new`.","title":"Dex Update","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Preview and safely adopt a Dex update through the receipt-backed lifecycle (look → back up → apply → verify → rewindable)."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-whats-new","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-whats-new/SKILL.md","summary":"The shipped Dex Whats New skill defines the workflow Lens is cataloguing."}],"impact_tier":"medium","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Show recent system improvements.","method_outline":["Inspect the current local state and the person's request.","Run the Dex Whats New workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Show recent system improvements — captured learnings plus new Claude capabilities. Use when the user says 'what's new', 'any updates to how Dex works'. Not for previewing and applying a version update; use `dex-update`. Not for unused existing features; use `dex-level-up`.","title":"Dex Whats New","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Show recent system improvements."},{"availability":"active","capability_class":"active-skill","capability_id":"diff-adopt","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/diff-adopt/SKILL.md","summary":"The shipped Diff Adopt skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Adopt one shared DexDiff methodology.","method_outline":["Inspect the current local state and the person's request.","Run the Diff Adopt workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.49.0","summary":"Adopt one shared DexDiff methodology — reads a workflow description, adapts it to your role and vault, and walks you through setup. Use when the user says 'adopt this workflow', 'set me up like this doc'. Not for a full published profile by handle; use `diff-adopt-profile`.","title":"Diff Adopt","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Adopt one shared DexDiff methodology."},{"availability":"active","capability_class":"active-skill","capability_id":"diff-adopt-profile","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/diff-adopt-profile/SKILL.md","summary":"The shipped Diff Adopt Profile skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Adopt a full published Heydex profile by handle ('set me up like @davekilleen').","method_outline":["Inspect the current local state and the person's request.","Run the Diff Adopt Profile workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.49.0","summary":"Adopt a full published Heydex profile by handle ('set me up like @davekilleen'). Use when the user says 'set me up like ', or names a handle. Not for a single workflow doc; use `diff-adopt`. Not for creating your own profile; use `diff-profile`.","title":"Diff Adopt Profile","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Adopt a full published Heydex profile by handle ('set me up like @davekilleen')."},{"availability":"active","capability_class":"active-skill","capability_id":"diff-generate","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/diff-generate/SKILL.md","summary":"The shipped Diff Generate skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Package one workflow.","method_outline":["Inspect the current local state and the person's request.","Run the Diff Generate workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.49.0","summary":"Package one workflow — how you use Dex for a specific job — into a shareable DexDiff methodology doc. Use when the user says 'share how I do X', 'package this workflow'. Not for packaging your *entire* system; use `diff-profile`. Not for adopting someone else's; use `diff-adopt`.","title":"Diff Generate","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Package one workflow."},{"availability":"active","capability_class":"active-skill","capability_id":"diff-list","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/diff-list/SKILL.md","summary":"The shipped Diff List skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Show all adopted DexDiff workflows.","method_outline":["Inspect the current local state and the person's request.","Run the Diff List workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.49.0","summary":"Show all adopted DexDiff workflows — what's installed, when it was adopted, and what it includes","title":"Diff List","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Show all adopted DexDiff workflows."},{"availability":"active","capability_class":"active-skill","capability_id":"diff-profile","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/diff-profile/SKILL.md","summary":"The shipped Diff Profile skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Package your entire Dex system into a shareable DexDiff profile so others can replicate how you work.","method_outline":["Inspect the current local state and the person's request.","Run the Diff Profile workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.49.0","summary":"Package your entire Dex system into a shareable DexDiff profile so others can replicate how you work. Use when the user says 'share my whole setup', 'publish my profile'. Not for a single workflow; use `diff-generate`. Not for adopting a whole profile; use `diff-adopt-profile`.","title":"Diff Profile","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Package your entire Dex system into a shareable DexDiff profile so others can replicate how you work."},{"availability":"active","capability_class":"active-skill","capability_id":"diff-remove","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/diff-remove/SKILL.md","summary":"The shipped Diff Remove skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Remove a previously adopted DexDiff workflow.","method_outline":["Inspect the current local state and the person's request.","Run the Diff Remove workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.49.0","summary":"Remove a previously adopted DexDiff workflow — deletes its generated skills and config, leaves your data untouched. Use when the user says 'remove that workflow', 'undo the adoption'. Not for listing what's installed; use `diff-list`.","title":"Diff Remove","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Remove a previously adopted DexDiff workflow."},{"availability":"active","capability_class":"active-skill","capability_id":"enable-semantic-search","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","privacy-minimal-disclosure","ownership-portability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","local-search-index","durable-memory-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/enable-semantic-search/SKILL.md","summary":"The shipped skill defines the pre-flight checks, the guided local install, the collections it discovers from the person's own material, and the later health check on those collections. There is no test of the workflow's own judgement calls; the shipped skill file is the definition of the behaviour, which is why this entry claims support rather than proof."}],"impact_tier":"high","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Add meaning-based search over the person's own notes, running locally, without sending their material anywhere.","method_outline":["Check what is already installed before proposing anything.","Explain in plain terms what is being installed and roughly what it costs in space.","Discover the natural groupings in the person's own material rather than imposing one.","Fall back cleanly to exact-word search wherever the index is unavailable."],"rollback_advice":"Remove the local search index and its tool; every workflow that used it falls back to exact-word search, and the notes themselves are never modified.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Notes never leave the person's machine as part of the setup.","A search by meaning finds a note that shares no words with the query.","Every routine that uses it still works when the index is absent."]},"prerequisites":["A one-off local setup with room on the machine for the search index.","Enough accumulated notes that exact-word searching is already missing things."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Turn on local AI-powered semantic (meaning-based) search over the vault, with smart collection discovery. Use when the user says 'enable semantic search', 'search by meaning', 'set up QMD', or search keeps missing obvious matches. Not for scraping the web; use `scrape`.","title":"Enable Semantic Search","trade_offs":["The guided setup names macOS package steps; other systems need their own equivalents.","Meaning-based results are broader than exact matches, so an occasional loose result is the price of finding the right one."],"value":"Makes the person's own notes searchable by meaning rather than exact wording, on their own machine — so looking for “customer churn” still finds the note that said “people keep leaving”."},{"availability":"active","capability_class":"active-skill","capability_id":"feedback","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/feedback/SKILL.md","summary":"The shipped Feedback skill defines the workflow Lens is cataloguing."}],"impact_tier":"core","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Report a Dex bug to the Dex team with zero homework.","method_outline":["Inspect the current local state and the person's request.","Run the Feedback workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.82.0","summary":"Report a Dex bug to the Dex team with zero homework — Dex investigates locally, builds a privacy-safe report, shows it to you (or auto-sends if you've chosen that), and tracks the ticket until it's fixed. Use when the user says \"report this\", \"send this to the Dex team\", \"file feedback\", \"/feedback\", asks \"what happened to my bug report\", or accepts Doctor's offer to report a Dex bug. Also use when the user describes something in Dex misbehaving in their own words, without asking for a report at all — \"the meeting sync is doing something weird\", \"this keeps breaking\", \"X stopped working\", \"that's not what I asked for\" — investigate first, then offer. Not for capturing ideas about your own vault or workflow; use the improvements backlog for those. Not for trouble in the user's own notes, calendar or projects, which is never a Dex defect.","title":"Feedback","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Report a Dex bug to the Dex team with zero homework."},{"availability":"active","capability_class":"active-skill","capability_id":"getting-started","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/getting-started/SKILL.md","summary":"The shipped Getting Started skill defines the workflow Lens is cataloguing."}],"impact_tier":"core","jobs":["start-each-day-focused"],"portable_brief":{"goal":"Give a new Dex user a practical post-onboarding tour that adapts to the data already available.","method_outline":["Inspect the current local state and the person's request.","Run the Getting Started workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Interactive post-onboarding tour that adapts to whatever data exists (calendar, Granola, or none). Use right after onboarding, or when the user says 'show me around', 'how do I start'. Also use proactively when the vault is < 7 days old. Not for the initial setup itself; use `setup`.","title":"Getting Started","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Interactive post-onboarding tour that adapts to whatever data exists (calendar, Granola, or none). Use right after onboarding, or when the user says 'show me around', 'how do I start'. Also use proactively when the vault is < 7 days old. Not for the initial setup itself; use `setup`."},{"availability":"active","capability_class":"active-skill","capability_id":"goal-backlog","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-goals-or-tasks","task-or-note-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_instruction_honesty.py","summary":"Pins the load-bearing promises: no task is deleted or moved silently, deletions are previewed line by line and approved per task, parking preserves content, and the offer to structure freeform goals is made once. The tests read the shipped instructions."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_work_server_task_goal_readers.py","summary":"Covers the grouped backlog reader the skill drives: grouping by goal, the pick-up-first ordering, staleness counts, and the handling of provisional goals recovered from freeform text."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/goal-backlog/SKILL.md","summary":"The shipped skill defines the one-goal-at-a-time pass, the four honest exits for stale work, and the rule that nothing leaves the backlog without a yes."}],"impact_tier":"high","jobs":["manage-tasks-reliably"],"portable_brief":{"goal":"Create a grooming pass that shows open work under each quarter goal and records the user's own decisions about what stays, what goes, and what gets picked up first.","method_outline":["Load the grouped backlog and present the largest and stalest groups first.","Confirm or clear each doubtful goal link before anything else.","Offer four exits for stale work - done, parked, deleted with per-task approval, or kept.","Record the pick-up-first order weekly planning will pull from."],"rollback_advice":"Move a parked task's lines back from the Someday file to the tasks file to revive it; ask to clear a pick-up-first order to undo it. Deletions are the one permanent exit, which is why each requires its own yes.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Nothing is deleted or moved without the exact lines shown and a yes for that task.","The offer to structure freeform goals is made once, never repeated after a no.","An empty backlog is reported as empty, not padded with invented work."]},"prerequisites":["Quarterly goals in the structured page shape, so tasks can link to them.","An open task backlog in the standard tasks file."],"release_provenance":"core-release","since_release":"1.97.7","summary":"Groom the open task pool goal by goal: see everything under each quarter goal, confirm doubtful goal links, retire what has gone stale, and mark what gets picked up first when that goal earns week-time. Use when the user says 'groom my backlog', 'what's under this goal', 'my tasks are a swamp', 'clean up my tasks', or when open tasks have piled up untouched. Not for routing new inbox items; use `triage`. Not for setting the week's priorities; use `week-plan`.","title":"Goal Backlog","trade_offs":["Staleness is measured from when a task was created, not from real activity, so a task advanced elsewhere can look idle.","Every retirement is confirmed item by item, which costs attention on a large backlog."],"value":"Turns a flat, overgrown task list back into a groomed pool: open work shown goal by goal, doubtful links confirmed, stale items retired only with approval, and a picked-up-first order that weekly planning actually uses."},{"availability":"active","capability_class":"active-skill","capability_id":"google-workspace-setup","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/google-workspace-setup/SKILL.md","summary":"The shipped Google Workspace Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["capture-without-friction"],"portable_brief":{"goal":"Connect Google Workspace (Gmail, Calendar, Docs) for email-aware planning and meeting prep.","method_outline":["Inspect the current local state and the person's request.","Run the Google Workspace Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Connect Google Workspace (Gmail, Calendar, Docs) for email-aware planning and meeting prep. Use when the user says 'connect Gmail/Google', 'hook up my work email'. Not for local macOS calendar speed only; use `calendar-setup`. Not for Microsoft; use `ms-teams-setup`.","title":"Google Workspace Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Google Workspace (Gmail, Calendar, Docs) for email-aware planning and meeting prep."},{"availability":"active","capability_class":"active-skill","capability_id":"granola-setup","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/granola-setup/SKILL.md","summary":"The shipped Granola Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["capture-without-friction"],"portable_brief":{"goal":"Connect Granola via its official API for automatic meeting sync and transcripts.","method_outline":["Inspect the current local state and the person's request.","Run the Granola Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Connect Granola via its official API for automatic meeting sync and transcripts. Use when the user says 'connect Granola', 'my meetings aren't syncing', 'set up meeting notes'. Not for Zoom recordings; use `zoom-setup`. Not for processing meetings already synced; use `process-meetings`.","title":"Granola Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Granola via its official API for automatic meeting sync and transcripts."},{"availability":"active","capability_class":"active-skill","capability_id":"identity-snapshot","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability","honest-health-observability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-memory-store","durable-goals-or-tasks"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/identity-snapshot/SKILL.md","summary":"The shipped skill defines the sources it reads, the structure of the profile it writes, and its rule to report a neglected area honestly rather than flatter the person. There is no test of the workflow's own judgement calls; the shipped skill file is the definition of the behaviour, which is why this entry claims support rather than proof."}],"impact_tier":"high","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Create an observed profile of how a person works, generated from their own records rather than from self-description.","method_outline":["Read the accumulated goals, priorities, tasks and captured learnings.","Describe patterns using actual data points, not general statements.","Say plainly where an area is neglected or where pace dropped.","Date every generation so change over time is visible."],"rollback_advice":"Delete the generated profile; it is written from other records and never modifies them, so removing it loses nothing else.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Nothing in the profile was asked of the person directly.","A missing source is marked as missing rather than smoothed over.","Each claim can be traced to a specific record."]},"prerequisites":["Enough accumulated history for a pattern to exist; a new system has nothing to read.","A place for the profile to live and be replaced as it changes."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Generate a living profile of the user's working patterns, decision tendencies and quality preferences from their Dex data. Use when the user says 'what are my patterns', 'how do I work', or during `week-review`. Also use proactively when the model (older than 7 days) is stale. Not for planning a week; use `week-plan`.","title":"Identity Snapshot","trade_offs":["It sees only what was captured, so habits that never got written down are invisible to it.","Generated too early it describes noise; it becomes useful after months of material."],"value":"Writes a dated profile of how the person actually works, built from their own accumulated records rather than from what they say about themselves — so drift over months becomes visible."},{"availability":"active","capability_class":"active-skill","capability_id":"industry-truths","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability","context-orientation"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-memory-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/industry-truths/SKILL.md","summary":"The shipped skill defines the three time horizons, the interview that draws the beliefs out, and the later passes that review them and compare them against what actually happened. There is no test of the workflow's own judgement calls; the shipped skill file is the definition of the behaviour, which is why this entry claims support rather than proof."}],"impact_tier":"high","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Create a record of time-horizoned beliefs about a market so strategic choices can be checked against stated assumptions.","method_outline":["Draw out beliefs by conversation rather than by form-filling.","Separate them into what is true now, what is emerging, and what is a bet.","Record who or what the person watches for signals of change.","Schedule a later pass that compares the beliefs against what actually happened."],"rollback_advice":"Delete the assumptions file; it is a standalone record, and strategy notes that referenced it simply lose the link.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Each belief is specific enough to be proved wrong.","The horizon each belief sits in is explicit.","There is a stated point at which the beliefs get reviewed."]},"prerequisites":["A domain the person genuinely follows, and roughly fifteen minutes of conversation.","A willingness to be wrong in writing; the value arrives when the beliefs are checked later."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Define time-horizoned assumptions about your industry (today / 6mo / 12mo) that ground strategic thinking. Use when the user is making roadmap, positioning or investment calls, or says 'what am I assuming about the market'. Also use proactively before a big strategic recommendation. Not for capturing a single decision; use `decision-log`.","title":"Industry Truths","trade_offs":["Assumptions written once and never revisited age badly, and can mislead more than having none.","It records beliefs, not evidence; the sources behind them remain the person's responsibility."],"value":"Makes the beliefs a strategy rests on explicit — what is true today, in six months, in a year — so later decisions can be checked against them instead of quietly assuming them."},{"availability":"active","capability_class":"active-skill","capability_id":"initiative-kickoff","changed_in":[],"compatibility":{"foundation_capabilities":["scoped-agency-human-control","durable-memory-provenance","context-orientation"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-goals-or-tasks","project-records"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_initiative_kickoff_skill.py","summary":"Dedicated tests pin the load-bearing promises: success signals must be checkable, no connection to a goal is manufactured where none fits, nothing is created without confirmation, and the person's setting for creating new people records is respected. The tests read the shipped instructions, not a live kickoff."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/initiative-kickoff/SKILL.md","summary":"The shipped skill defines the framing questions, the honest ladder to goals, and the read-back of what was created before anything is called kicked off."}],"impact_tier":"high","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Create a kickoff routine that turns a decision to start something into an outcome, checkable success signals, an owner and first steps.","method_outline":["Get the outcome, the reason it is worth starting now, and what is out of scope.","Name two to four signals somebody could actually check later.","Name the accountable owner and the people involved.","Connect it to a real existing goal, or record it honestly as a standalone bet.","Draft the first few steps and create only the ones confirmed."],"rollback_advice":"Delete the initiative record and the first steps it created; nothing else in the person's goals or projects is altered by the kickoff.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every success signal could be verified by someone else months later.","No connection to a goal exists that the goals themselves do not support.","What is reported as created matches what actually exists."]},"prerequisites":["A decision already taken; this is where a decision becomes work, not where it gets made.","Somewhere to keep the initiative, and existing goals to connect it to if any exist."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Turn a decision to start something new — a hire, a partnership, a go-to-market push, an internal bet — into a real initiative: the outcome and why now, what success looks like, who's involved, the first concrete steps, and a project page that ladders to your pillars and goals. Use when the user says 'let's kick off X', 'I'm starting a new initiative', 'set up a project for this', or 'we've decided to do Y'. Also use proactively when the user commits to a new effort mid-conversation. Not for spec'ing a product feature or writing a PRD; use `product-brief`. Not for checking the status of projects already underway; use `project-health`.","title":"Initiative Kickoff","trade_offs":["Where an initiative does not connect to a real goal it is recorded as a standalone bet rather than tied to an invented one.","Success signals have to be checkable later, which takes more thought up front than a general aim."],"value":"Turns “we’ve decided to do this” into something that can actually start: an outcome, signs of success somebody could check later, a named owner and the first few steps."},{"availability":"active","capability_class":"active-skill","capability_id":"integrate-mcp","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/integrate-mcp/SKILL.md","summary":"The shipped Integrate Mcp skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Install and wire up an existing MCP server from Smithery.ai or a GitHub repo.","method_outline":["Inspect the current local state and the person's request.","Run the Integrate Mcp workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Install and wire up an existing MCP server from Smithery.ai or a GitHub repo. Use when the user names a tool that already has a server — 'add the Notion MCP', 'install this Smithery server'. Not for building a new integration from nothing; use `create-mcp`. Not for adding one already-known server safely; use `dex-add-mcp`.","title":"Integrate Mcp","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Install and wire up an existing MCP server from Smithery.ai or a GitHub repo."},{"availability":"active","capability_class":"active-skill","capability_id":"journal","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/journal/SKILL.md","summary":"The shipped Journal skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Toggle journaling or start a morning/evening/weekly journal entry.","method_outline":["Inspect the current local state and the person's request.","Run the Journal workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Toggle journaling or start a morning/evening/weekly journal entry. Use when the user says 'journal', 'morning pages', 'evening reflection'. Also use proactively when a journaling-enabled user starts/ends the day. Not for a structured end-of-day work review; use `daily-review`.","title":"Journal","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Toggle journaling or start a morning/evening/weekly journal entry."},{"availability":"active","capability_class":"active-skill","capability_id":"manage-capabilities","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/manage-capabilities/SKILL.md","summary":"The shipped Manage Capabilities skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Turn optional Dex rooms/features on or off without deleting any content.","method_outline":["Inspect the current local state and the person's request.","Run the Manage Capabilities workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.63.0","summary":"Turn optional Dex rooms/features on or off without deleting any content. Use when the user says 'turn off X', 'enable the career room', 'hide a feature I don't use'. Not for diagnosing breakage; use `dex-doctor`. Not for a full role restructure; use `reset`.","title":"Manage Capabilities","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Turn optional Dex rooms/features on or off without deleting any content."},{"availability":"active","capability_class":"active-skill","capability_id":"meeting-closeout","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","scoped-agency-human-control","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","meeting-source","task-or-note-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_meeting_closeout_skill.py","summary":"Dedicated tests pin the load-bearing promises: this is one meeting rather than a bulk catch-up, owners are named or honestly marked unknown, the person's setting for creating new people records is respected, no task is created without confirmation, and a meeting it cannot find is asked for rather than reconstructed. The tests read the shipped instructions, not a live meeting."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/meeting-closeout/SKILL.md","summary":"The shipped skill defines the closeout, the hard boundary on where meeting material may be read from, and the read-back before anything is reported as captured."}],"impact_tier":"high","jobs":["capture-without-friction"],"portable_brief":{"goal":"Create a single-meeting closeout that captures decisions, owners, personal promises and one next step while they are still fresh.","method_outline":["Work only from notes the person supplied or from their own configured store.","Extract decisions, action items with a named owner, personal promises and one next step.","Mark an owner the notes do not name as unknown instead of assigning one.","Offer each follow-up for confirmation, then read back what was actually saved."],"rollback_advice":"Delete the generated closeout note and any follow-ups it created; the original meeting notes are appended to or left alone, never rewritten.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["No decision, owner or promise appears that the notes do not support.","A meeting with no available notes produces a request, never a recap.","What is reported as saved matches what is actually on disk."]},"prerequisites":["Notes from the meeting — pasted, dictated, or already saved wherever the person keeps them.","Somewhere to write the follow-ups the person approves."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Close out the meeting you just had while it's fresh — lock the decisions, the action items and who owns each, what you personally committed to, and the single next step — then capture it and, only with your OK, turn the actions into tracked tasks. Use when the user says 'wrap up this meeting', 'close out my 3pm', 'here are my notes from the call', or right after a meeting ends. Also use proactively when the user pastes raw notes from a meeting that just happened. Not for bulk-processing many already-synced meetings; use `process-meetings`. Not for prepping a meeting that hasn't happened yet; use `meeting-prep`.","title":"Meeting Closeout","trade_offs":["It will not go looking in outside services for a meeting it cannot find; it asks for the notes instead.","Owners the notes do not name are recorded as unknown rather than guessed, which leaves real gaps visible."],"value":"Locks one meeting's decisions, owners and personal promises while it is still fresh, and refuses to invent an owner or a recap for a meeting it cannot actually see."},{"availability":"active","capability_class":"active-skill","capability_id":"meeting-prep","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","privacy-minimal-disclosure","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","relationship-history","meeting-source"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_meeting_prep_calendar_journey.py","summary":"Statically checks the calendar-first instruction contract and journey order across the inline skill and delegated research prompt, including required attendee filters, feature-status guidance, and the structured person-page handoff; it does not simulate Calendar MCP runtime behavior."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_instruction_honesty.py","summary":"A dedicated test pins that this capability reports a source that is switched off or broken in Dex's honest wording, rather than letting a gap in the gathering pass as a finished brief."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_skill_delegated_gathering.py","summary":"Covers the paired gathering instructions the prep depends on when the history is large, so the reading step cannot be orphaned by a later edit."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/meeting-prep/SKILL.md","summary":"The shipped skill defines what is gathered, how the brief is shaped for the person's seniority and preferences, and the requirement to spot-check claims before presenting them."}],"impact_tier":"high","jobs":["capture-without-friction"],"portable_brief":{"goal":"Create a pre-meeting brief that gathers attendee history and open threads from approved sources and states what it could not find.","method_outline":["Identify the meeting and its attendees from the calendar or the person's own words.","Read only approved history: past notes, people records, related project material.","Confirm a sample of the files the brief cites actually exist before repeating them.","Present context, open threads and suggested talking points, and name the gaps."],"rollback_advice":"Stop running the routine; the brief is produced for the conversation and changes nothing in the person's own records, so there is nothing to unwind.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every claim in the brief traces to a file that exists.","Missing history is stated as missing rather than filled in plausibly.","No source outside the approved reading scope is opened."]},"prerequisites":["A calendar entry, or simply the meeting named out loud.","Some history worth gathering: earlier notes, people records or related project material."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Prepare for a specific upcoming meeting by gathering attendee context, history and related topics. Use when the user says 'prep me for my meeting with X', 'what do I need for the 2pm', or before a calendar event. Also use proactively when a meeting is imminent. Not for writing up a meeting that already happened; use `process-meetings`.","title":"Meeting Prep","trade_offs":["A brief is only as good as the history already captured; a genuinely first meeting has little to gather.","Anything the brief claims should be checked against the real file before it is repeated in the room."],"value":"Walks into the meeting already holding the attendees, the history and the open threads, instead of spending the last five minutes searching for them."},{"availability":"active","capability_class":"active-skill","capability_id":"ms-teams-setup","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/ms-teams-setup/SKILL.md","summary":"The shipped Ms Teams Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["track-people-and-relationships"],"portable_brief":{"goal":"Connect Microsoft Teams for cross-channel context awareness.","method_outline":["Inspect the current local state and the person's request.","Run the Ms Teams Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Connect Microsoft Teams for cross-channel context awareness. Use when the user says 'connect Teams', 'hook up Microsoft'. Not for Google email/calendar; use `google-workspace-setup`.","title":"Ms Teams Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Microsoft Teams for cross-channel context awareness."},{"availability":"active","capability_class":"active-skill","capability_id":"pipedrive-setup","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/pipedrive-setup/SKILL.md","summary":"The shipped Pipedrive Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["track-people-and-relationships"],"portable_brief":{"goal":"Connect Pipedrive CRM for a live pipeline view and confirm-gated deal updates.","method_outline":["Inspect the current local state and the person's request.","Run the Pipedrive Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.95.1","summary":"Connect Pipedrive CRM for a live pipeline view and confirm-gated deal updates. Use when the user says 'connect Pipedrive', 'link my CRM', 'sync my pipeline with Pipedrive'. Not for pipeline analysis without a CRM; use `pipeline-health`. Not for reconciling an already-connected CRM; use `pipeline-sync`.","title":"Pipedrive Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Pipedrive CRM for a live pipeline view and confirm-gated deal updates."},{"availability":"active","capability_class":"active-skill","capability_id":"pipeline-sync","changed_in":[],"compatibility":{"foundation_capabilities":["scoped-agency-human-control","honest-health-observability","safe-change-recovery","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","pipedrive-connection","pipeline-sync-companion"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions cover partial reads, prerequisites, confirmation and recovery limits."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_pipedrive_server.py","summary":"Pipedrive adapter tests support key read and write safety behavior, not complete synchronization."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/pipeline-sync/SKILL.md","summary":"The active release skill defines the pipeline reconciliation workflow."}],"impact_tier":"high","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Reconciles Pipedrive deal facts with local strategy notes through explicit previews and read-back checks.","method_outline":["Discover complete deal and note inputs.","Map differences without treating partial reads as complete.","Preview, confirm and read back each approved reconciliation."],"rollback_advice":"Stop the reconciliation and keep both systems unchanged; use the last preview and read-back receipt to recover any confirmed partial update.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Incomplete reads remain visibly incomplete.","A retry does not assume idempotency without proof."]},"prerequisites":["A configured Pipedrive connection the host can read.","The pipeline-sync companion instructions and explicit authority for any proposed write."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Live view of your Pipedrive pipeline reconciled against your local pipeline tracker; flags drift, maps focus deals, and pushes confirmed updates to the CRM. Use when the user says 'sync my pipeline', 'show me my pipeline', 'reconcile the CRM'. Not for connecting Pipedrive in the first place; use `pipedrive-setup`.","title":"Pipeline Sync","trade_offs":["It requires both the Pipedrive connection and its companion instructions; write behavior remains human-confirmed and only supported, not behaviorally verified.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Reconciles Pipedrive deal facts with local strategy notes through explicit previews and read-back checks."},{"availability":"active","capability_class":"active-skill","capability_id":"process-meetings","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","meeting-source","task-or-note-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_process_meetings_soft_commitment_wiring.py","summary":"Meeting processing is covered where soft commitments are detected and routed."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/process-meetings/SKILL.md","summary":"The shipped skill defines the meeting processing workflow."}],"impact_tier":"core","jobs":["capture-without-friction","track-people-and-relationships"],"portable_brief":{"goal":"Create a meeting processing routine that extracts decisions, commitments and relationship context from approved meeting material.","method_outline":["Read only the approved meeting source.","Identify decisions, action items and people references.","Offer reviewable tasks or note updates."],"rollback_advice":"Disable the meeting processor and remove generated follow-up drafts; keep original meeting notes untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["No unrelated meeting content is read.","Every proposed follow-up cites the meeting source.","The person can edit before task creation."]},"prerequisites":["Meeting notes or transcripts in a readable local source.","A place to write reviewable follow-up tasks."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Turn synced meetings into updated person pages, extracted tasks and organized notes. Use when the user says 'process my meetings', 'catch up my notes', or after Granola/Otter syncs. Also use proactively when unprocessed meetings exist. Not for prepping an upcoming meeting; use `meeting-prep`.","title":"Process Meetings","trade_offs":["Transcript quality controls output quality.","Private meeting material must stay within the host's declared read scope."],"value":"Turns meeting material into people context and follow-up tasks, reducing the chance that decisions or promises disappear after the call."},{"availability":"active","capability_class":"active-skill","capability_id":"product-brief","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","project-records"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/product-brief/SKILL.md","summary":"The shipped skill defines the guided extraction, the questions asked in conversation rather than as a form, and the structure of the brief it produces. There is no test of the workflow's own judgement calls; the shipped skill file is the definition of the behaviour, which is why this entry claims support rather than proof."}],"impact_tier":"high","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Create a guided questioning routine that turns a rough product idea into a written brief a team could execute.","method_outline":["Start from whatever the person has, however rough, without judging it.","Ask two or three questions at a time, conversationally, and wait for answers.","Fill the gaps that matter — who it is for, what problem, what success looks like.","Produce the written brief and keep it where the work will happen."],"rollback_advice":"Delete the generated brief; the questioning changes nothing else, so no other record needs restoring.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Nothing in the brief was supplied by the system rather than the person.","Open questions are listed as open, not resolved by assumption.","The brief is specific enough for someone else to act on."]},"prerequisites":["An idea worth the time; the questioning is guided but not instant.","Somewhere to keep the finished brief next to the work it belongs to."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Extract a product idea through guided questions and generate a PRD. Use when the user says 'write a PRD', 'spec this feature', 'turn this idea into a brief'. Not for a non-product initiative like hiring or partnerships (use `initiative-kickoff` once shipped); not for checking existing projects' status (use `project-health`).","title":"Product Brief","trade_offs":["The brief is only as sharp as the answers given; it will not invent a market, a user or a measure.","It is shaped around product work, so a hire, a partnership or an operational bet is served better elsewhere."],"value":"Draws a half-formed product idea out through questions and leaves a written brief a team could actually build from, instead of an idea that only made sense in one head."},{"availability":"active","capability_class":"active-skill","capability_id":"project-health","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","project-records"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/project-health/SKILL.md","summary":"The shipped skill defines the four checks it makes per project — activity, active tasks, blockers and next-step clarity — and the traffic-light thresholds behind them. There is no test of the workflow's own judgement calls; the shipped skill file is the definition of the behaviour, which is why this entry claims support rather than proof."}],"impact_tier":"high","jobs":["start-each-day-focused"],"portable_brief":{"goal":"Create a fast scan across active projects that reports what is stale, blocked or missing a clear next step.","method_outline":["List the active projects and read when each last changed.","Check whether each has current tasks, a recorded blocker and a clear next action.","Report one line per project with the reason it was flagged.","Keep the output short enough to read in one pass."],"rollback_advice":"Stop running the scan; it reads project material and writes a report, so removing the report leaves the projects exactly as they were.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every flag names the specific reason it was raised.","Thresholds for stale and blocked are stated, not implied.","A healthy project takes one line, not a paragraph."]},"prerequisites":["Project notes the scan can read.","Some record of recent activity, so going quiet means something."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Scan active projects for status, blockers and next actions. Use when the user says 'how are my projects', 'what's stuck', 'project status'. Also use proactively when projects have gone quiet. Not for writing a spec for a new product idea; use `product-brief`.","title":"Project Health","trade_offs":["Quietness is judged from when project files last changed, which misreads work happening somewhere else.","It is deliberately small: it flags what to look at, it does not diagnose why."],"value":"Answers “what’s stuck?” across every active project in one pass: how long since anything moved, what is blocked, and whether the next step is actually clear."},{"availability":"active","capability_class":"active-skill","capability_id":"prompt-improver","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/prompt-improver/SKILL.md","summary":"The shipped Prompt Improver skill defines the workflow Lens is cataloguing."}],"impact_tier":"medium","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Rewrite a vague prompt into a rich, structured one, with automatic fallback.","method_outline":["Inspect the current local state and the person's request.","Run the Prompt Improver workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Rewrite a vague prompt into a rich, structured one, with automatic fallback. Use when the user says 'improve this prompt', 'make this prompt better', or hands over a thin instruction. Not for creating a reusable skill; use `create-skill`.","title":"Prompt Improver","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Rewrite a vague prompt into a rich, structured one, with automatic fallback."},{"availability":"active","capability_class":"active-skill","capability_id":"relationship-radar","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["relationship-history","skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_relationship_radar_skill.py","summary":"Relationship radar skill behavior is covered in the skill test."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/relationship-radar/SKILL.md","summary":"The shipped skill defines the cold-relationship workflow."}],"impact_tier":"high","jobs":["track-people-and-relationships"],"portable_brief":{"goal":"Create a relationship review that identifies important contacts with stale recent engagement.","method_outline":["Read approved relationship or meeting evidence.","Rank by importance and recency.","Suggest reviewable next actions rather than sending messages."],"rollback_advice":"Remove the radar command or delete its generated suggestions; do not alter source relationship history.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The output names why each person surfaced.","No message is sent automatically.","The person can dismiss or defer a suggestion."]},"prerequisites":["A relationship or meeting history source.","A rule for what counts as important enough to surface."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Spot the relationships going cold — people you were in regular contact with and haven't touched in a while, and important contacts who are slipping — ranked by how stale each has become, so you can reconnect before it costs you. Use when the user says 'who should I reach out to', 'who am I losing touch with', 'who's going cold', 'who needs attention', or during a weekly review. Also use proactively when someone important hasn't come up in a long time. Not for prepping a specific upcoming meeting; use `meeting-prep`. Not for specific promises you owe people; use `commitments`.","title":"Relationship Radar","trade_offs":["Recency signals can miss context the system cannot see.","The person still decides whether to reach out."],"value":"Shows important relationships that are going quiet so the person can reconnect before silence becomes a problem."},{"availability":"active","capability_class":"active-skill","capability_id":"reset","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/reset/SKILL.md","summary":"The shipped Reset skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Restructure an existing Dex vault for a new role or changed preferences, without losing data.","method_outline":["Inspect the current local state and the person's request.","Run the Reset workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Re-run the setup questions over an existing Dex vault when preferences or setup answers changed, without losing data. Use when the user says 'restructure my Dex', 'redo my setup', 'my pillars are wrong now'. Not for a job or role change; use `change-job` — it runs this same reset plus the people, archive and task passes. Not for first-time setup; use `setup`. Not for just toggling one feature; use `manage-capabilities`.","title":"Reset","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Restructure an existing Dex vault for a new role or changed preferences, without losing data."},{"availability":"active","capability_class":"active-skill","capability_id":"review","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/review/SKILL.md","summary":"The shipped Review skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Keeps the old review command working by handing it directly to the current daily review workflow.","method_outline":["Inspect the current local state and the person's request.","Run the Review workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Deprecation alias for `daily-review`. The end-of-day review was renamed; `/review` now redirects to `daily-review` and will be removed after one release. Use when the user types `/review` out of habit — hand straight off to `daily-review`, which owns end-of-day review and learning capture. Not for running the review here; use `daily-review`.","title":"Review","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Keeps the old review command working by handing it directly to the current daily review workflow."},{"availability":"active","capability_class":"active-skill","capability_id":"save-insight","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability","context-orientation"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["durable-memory-store","skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_learning_capture_command_name.py","summary":"Learning capture command naming is pinned by tests."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/save-insight/SKILL.md","summary":"The shipped skill defines the reusable-learning capture flow."}],"impact_tier":"high","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Create a lightweight learning capture routine for reusable lessons from completed work.","method_outline":["Ask what changed future behavior.","Store only the reusable rule and source context.","Prefer small scoped memories over broad summaries."],"rollback_advice":"Delete or archive the saved learning entry; keep original project records separate.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The saved item has a clear reuse condition.","It does not contain secrets or raw private material.","Future work can cite where it came from."]},"prerequisites":["A durable memory or notes store.","A review habit for deciding what is worth keeping."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Capture a reusable learning from completed work so future similar work is easier. Use when the user says 'save this learning', 'capture this insight', or finishes something tricky. Also use proactively after non-routine work. Not for recording a *decision* and its rationale; use `decision-log`.","title":"Save Insight","trade_offs":["Low-quality memories can clutter future context.","The person or system needs a rule for when to save learning."],"value":"Turns a learning from completed work into durable context future agents can reuse instead of rediscovering it."},{"availability":"active","capability_class":"active-skill","capability_id":"scrape","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/scrape/SKILL.md","summary":"The shipped Scrape skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Scrape web pages via Scrapling.","method_outline":["Inspect the current local state and the person's request.","Run the Scrape workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Scrape web pages via Scrapling — stealth fetching, anti-bot bypass, CSS selectors, no API key. Use when the user says 'scrape', 'pull data from this URL', 'extract from this site'. Not for meaning-based search of the user's own vault; use `enable-semantic-search`.","title":"Scrape","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Scrape web pages via Scrapling."},{"availability":"active","capability_class":"active-skill","capability_id":"setup","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/setup/SKILL.md","summary":"The shipped Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"core","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Run first-time Dex onboarding: build the vault structure, capture the user profile and configure MCPs.","method_outline":["Inspect the current local state and the person's request.","Run the Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Run first-time Dex onboarding: build the vault structure, capture the user profile and configure MCPs. Use when `System/.onboarding-complete` is absent or the user says 'set up Dex', 'start onboarding'. Not for the post-onboarding tour; use `getting-started`. Not for a mid-life role change; use `reset`.","title":"Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Run first-time Dex onboarding: build the vault structure, capture the user profile and configure MCPs."},{"availability":"active","capability_class":"active-skill","capability_id":"skill-score","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/skill-score/SKILL.md","summary":"The shipped Skill Score skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Grade a Dex skill against the shape-aware quality rubric and report a ship/revise/no verdict with the exact fixes.","method_outline":["Inspect the current local state and the person's request.","Run the Skill Score workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.69.0","summary":"Grade a Dex skill against the shape-aware quality rubric and report a ship/revise/no verdict with the exact fixes. Use when you finish writing or editing a skill, when create-skill hands off a new package, before shipping a first-party skill, or when the user asks \"is this skill any good / will it fire / score my skill\". Also use proactively right after any SKILL.md is created or its description changes. Not for authoring a new skill from scratch (use create-skill) or fixing broken YAML frontmatter alone (create-skill's validator does that); skill-score judges architecture and routing, not just format.","title":"Skill Score","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Grade a Dex skill against the shape-aware quality rubric and report a ship/revise/no verdict with the exact fixes."},{"availability":"active","capability_class":"active-skill","capability_id":"things-setup","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/things-setup/SKILL.md","summary":"The shipped Things Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["manage-tasks-reliably"],"portable_brief":{"goal":"Connect Things 3 (macOS only) so Dex reads and updates your Things tasks.","method_outline":["Inspect the current local state and the person's request.","Run the Things Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Connect Things 3 (macOS only) so Dex reads and updates your Things tasks. Use when the user says 'I use Things', 'sync my Things inbox', or pastes a `things://` link. Not for Todoist (`todoist-setup`) or Trello (`trello-setup`).","title":"Things Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Things 3 (macOS only) so Dex reads and updates your Things tasks."},{"availability":"active","capability_class":"active-skill","capability_id":"todoist-setup","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/todoist-setup/SKILL.md","summary":"The shipped Todoist Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["manage-tasks-reliably"],"portable_brief":{"goal":"Connect Todoist so Dex reads and updates your Todoist tasks two ways.","method_outline":["Inspect the current local state and the person's request.","Run the Todoist Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Connect Todoist so Dex reads and updates your Todoist tasks two ways. Use when the user says 'I use Todoist', 'sync Todoist', or pastes a todoist.com link. Not for Things 3 (`things-setup`) or Trello (`trello-setup`); not for Jira tickets (`atlassian-setup`).","title":"Todoist Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Todoist so Dex reads and updates your Todoist tasks two ways."},{"availability":"active","capability_class":"active-skill","capability_id":"trello-setup","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/trello-setup/SKILL.md","summary":"The shipped Trello Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["manage-tasks-reliably"],"portable_brief":{"goal":"Connect Trello so Dex reads your boards and manages cards.","method_outline":["Inspect the current local state and the person's request.","Run the Trello Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Connect Trello so Dex reads your boards and manages cards. Use when the user says 'I use Trello', 'my Trello board', or pastes a trello.com link. Not for Todoist (`todoist-setup`) or Things (`things-setup`).","title":"Trello Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Trello so Dex reads your boards and manages cards."},{"availability":"active","capability_class":"active-skill","capability_id":"triage","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-goals-or-tasks","task-or-note-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/triage/SKILL.md","summary":"The shipped skill defines the routing workflow, the index it builds of existing projects and people, and the way current priorities raise confidence in a destination. There is no test of the workflow's own judgement calls; the shipped skill file is the definition of the behaviour, which is why this entry claims support rather than proof."}],"impact_tier":"core","jobs":["manage-tasks-reliably"],"portable_brief":{"goal":"Create a routing pass that clears loose captures into the right home using the person's current priorities.","method_outline":["Read current priorities and goals before touching the pile.","Build an index of the existing projects, people and areas that could receive an item.","Route each item to its best home, and leave anything genuinely unclear untouched.","Keep the decision per item fast; this is a clearing pass, not an analysis."],"rollback_advice":"Move the routed files back to the capture folder; the routing only relocates and links items, so their content is unchanged.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Items matching current priorities surface first.","Nothing is filed to a destination the person cannot recognise.","Unclear items are left in place rather than moved somewhere plausible."]},"prerequisites":["A capture folder or set of notes where loose items actually accumulate.","Current priorities or goals, so routing follows what matters now rather than in general."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Route orphaned inbox files and pull scattered `- [ ]` tasks into the right project/person/goal using current priorities. Use when the user says 'clean up my inbox', 'triage', 'sort out these notes'. Also use proactively when `00-Inbox/` is piling up. Not for updating notes from meetings; use `process-meetings`.","title":"Triage","trade_offs":["Routing is a fast suggestion rather than a considered judgement, and is meant to be reviewed.","An item with no clear home is left where it is rather than filed somewhere merely plausible."],"value":"Clears the pile-up: loose files and stray unticked boxes get routed to the project, person or goal they belong to, weighted by what the person said matters this week."},{"availability":"active","capability_class":"active-skill","capability_id":"week-plan","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-goals-or-tasks"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_work_server_weekly_priority_creation.py","summary":"Weekly priority creation is covered through the Work MCP path."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/week-plan/SKILL.md","summary":"The shipped skill defines the weekly planning routine."}],"impact_tier":"high","jobs":["start-each-day-focused"],"portable_brief":{"goal":"Create a weekly planning routine that maps goals and commitments to a bounded set of priorities.","method_outline":["Read goals, open tasks and calendar pressure.","Select a short priority set for the week.","Expose uncertainty instead of forcing a fake complete plan."],"rollback_advice":"Remove the weekly planning command or its scheduled reminder; preserve the underlying tasks and goals.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The plan names priorities, not a generic task dump.","Capacity limits are visible in the output."]},"prerequisites":["Some durable goal or task record the host can read.","A cadence for reviewing the plan."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Set the week's priorities against goals, calendar shape and task effort. Use when the user says 'plan my week', 'what should I focus on this week', or on their first working day. Also use proactively at the first session of a new week. Not for reviewing the week just past; use `week-review`.","title":"Week Plan","trade_offs":["A weekly plan can become stale mid-week unless the person revisits it.","It depends on honest capacity data."],"value":"Turns goals, capacity and open work into a weekly focus plan, so repeated work starts from priorities rather than a blank chat."},{"availability":"active","capability_class":"active-skill","capability_id":"week-review","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-goals-or-tasks"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_instruction_honesty.py","summary":"A dedicated test pins that the weekly review reads the person's own configured working week and lands on their last working day, rather than assuming everyone finishes on a Friday."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_skill_delegated_gathering.py","summary":"Covers the paired gathering instructions the weekly review depends on, so the bulk reading step cannot be orphaned by a later edit."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/week-review/SKILL.md","summary":"The shipped skill defines the weekly review, its insistence on concrete measures over percentages, and the goal and pattern discussion that stays with the person."}],"impact_tier":"high","jobs":["start-each-day-focused","reflect-and-improve-continuously"],"portable_brief":{"goal":"Create a weekly review that reports concrete finished work and honest gaps instead of a synthetic progress score.","method_outline":["Gather the week's priorities, completed work and meeting record first.","Report what finished, what did not, and what changed — in countable terms.","Surface repeating patterns as questions for the person rather than verdicts.","Confirm next week's priorities with the person before recording them."],"rollback_advice":"Stop running the routine and delete the generated weekly summaries; priorities and goals live in their own records and are left as they were.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["No percentage or score appears that the underlying data cannot support.","Unfinished work is named plainly rather than folded into an average.","The review runs on the person's own last working day, not a fixed one."]},"prerequisites":["A record of the week's priorities or goals to review against.","The person's own working week, so the review lands on their last working day rather than an assumed Friday."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Review the week with concrete accomplishments (not fake percentages), pattern detection and goal tracking. Use when the user says 'how was my week', 'week review', or it's their last working day. Also use proactively when a week's priorities are largely resolved. Not for planning the coming week; use `week-plan`.","title":"Week Review","trade_offs":["An honest review depends on the week having been written down as it happened.","The patterns it names are prompts for the person's judgement, not conclusions about them."],"value":"Reviews the week in concrete finished work and the patterns behind it, and deliberately refuses to invent a completion percentage that would make a bad week look measured."},{"availability":"active","capability_class":"active-skill","capability_id":"weekly-reflection","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","scoped-agency-human-control","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-memory-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_adoption_effective_behavior.py","summary":"Real behaviour coverage of how this capability is switched on and off again: the test adopts it through Dex's live change system, proves the change can be rewound exactly, and proves a rewind refuses rather than overwrite a file the person has since edited. That covers the switch-on path, not the reflection conversation itself."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/weekly-reflection/SKILL.md","summary":"The shipped skill defines the three questions, the one-at-a-time pacing, and the rule against turning a feeling into a task or forcing a positive lesson."}],"impact_tier":"high","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Create a short weekly reflection on how work felt, kept separate from any measure of what was produced.","method_outline":["Ask what gave energy, one question at a time, and reflect the answer back.","Ask what drained energy, and offer any pattern as a possibility rather than a diagnosis.","Ask for one small, observable change the person controls.","Offer to keep the answers; accept no as an answer."],"rollback_advice":"Delete the saved reflection entry; entries are appended, so earlier writing is untouched and removal restores the previous state.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The week is not graded, scored or turned into a lesson.","The chosen change is small enough to actually happen.","Nothing is saved that the person did not agree to save."]},"prerequisites":["A few quiet minutes; this is the one thing that cannot be done on the person's behalf.","Somewhere private to keep the answers, or the choice not to keep them at all."],"release_provenance":"core-release","since_release":"1.80.0","summary":"A short guided reflection on what energized you, what drained you, and one change for next week. Use when the user wants to reflect on how work *felt*, not what got done — 'reflect on my week', 'what's draining me'. Not for progress-and-goals tracking; use `week-review`.","title":"Weekly Reflection","trade_offs":["It deliberately does not measure or score the week, which some people will want instead.","Reflection compounds only if the answers are kept and read again later."],"value":"Three questions about how the week felt — what gave energy, what took it, one thing to change — kept deliberately separate from the record of what got done."},{"availability":"active","capability_class":"active-skill","capability_id":"wispr-setup","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/wispr-setup/SKILL.md","summary":"The shipped Wispr Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["capture-without-friction"],"portable_brief":{"goal":"Connect Wispr Flow so meeting captures arrive in the vault on their own.","method_outline":["Inspect the current local state and the person's request.","Run the Wispr Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.97.0","summary":"Connect Wispr Flow so meeting captures arrive in your vault on their own. Use when the user says 'connect Wispr', 'set up Wispr Flow', 'my Wispr meetings aren't in Dex'. Not for Granola; use `granola-setup`. Not for processing meetings already in the vault; use `process-meetings`.","title":"Wispr Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Wispr Flow so meeting captures arrive in the vault on their own."},{"availability":"active","capability_class":"active-skill","capability_id":"xray","changed_in":[],"compatibility":{"foundation_capabilities":["honest-health-observability","context-orientation","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory","local-diagnostics"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/xray/SKILL.md","summary":"The shipped skill defines the default mode that explains the current conversation, the deeper modes on how the system is built and how to extend it, and the show-the-work-then-explain-why structure. There is no test of the workflow's own judgement calls; the shipped skill file is the definition of the behaviour, which is why this entry claims support rather than proof."}],"impact_tier":"high","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Explain the mechanics of what the system just did, using the current conversation as the teaching material.","method_outline":["Identify what was read, written, and which tools ran in this conversation.","Explain why each step was necessary, in the person's own terms.","Connect each concrete step to the underlying idea it demonstrates.","End with what the person could change or extend themselves."],"rollback_advice":"Stop offering the explanation; it only reads and describes the conversation, so nothing in the person's system needs to be undone.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every step described actually happened in this conversation.","Nothing is presented as a health verdict about the system.","The explanation would make sense to someone who did not build it."]},"prerequisites":["A conversation that has actually done something worth explaining.","A host that can report the steps it took during that conversation."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Explain what just happened under the hood — the context, MCP tools, and hooks behind Dex's last response — as AI education. Use when the user says 'how did you do that', 'what just happened', 'explain the mechanics'. Not for a system health check; use `dex-doctor`.","title":"Xray","trade_offs":["It explains what happened; it is not a health check and will not say whether anything is broken.","The explanation is only as accurate as what the host exposes about its own run."],"value":"Explains what the system just did and why — which files it read, which tools ran, what was loaded before the conversation even started — so the person learns their own setup instead of trusting it blindly."},{"availability":"active","capability_class":"active-skill","capability_id":"zoom-setup","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/zoom-setup/SKILL.md","summary":"The shipped Zoom Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["capture-without-friction"],"portable_brief":{"goal":"Connect Zoom for meeting recordings, scheduling and transcript context.","method_outline":["Inspect the current local state and the person's request.","Run the Zoom Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Connect the official Zoom for Claude connector for meeting recordings, transcripts, AI summaries, cloud-recording lists and Zoom Chat/Canvas search. Use when the user says 'connect Zoom', 'pull my Zoom recordings', 'search my Zoom meetings'. Not for Granola-sourced notes; use `granola-setup`. Not for Teams; use `ms-teams-setup`.","title":"Zoom Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Zoom for meeting recordings, scheduling and transcript context."},{"availability":"dormant","capability_class":"active-skill","capability_id":"account-plan","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/sales/account-plan/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","track-people-and-relationships"],"portable_brief":{"goal":"Builds a sourced account plan that keeps goals, relationships, risks and next moves in one reviewable place.","method_outline":["Collect dated account facts with per-field provenance.","Separate knowns, unknowns and recommendations.","Preview any saved plan and read it back after confirmation."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Important claims cite their source and date.","No account write occurs without an exact confirmed preview."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Create or update strategic account plan","title":"Account Plan","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Builds a sourced account plan that keeps goals, relationships, risks and next moves in one reviewable place."},{"availability":"dormant","capability_class":"active-skill","capability_id":"call-prep","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","privacy-minimal-disclosure","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/sales/call-prep/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","capture-without-friction","track-people-and-relationships"],"portable_brief":{"goal":"Turns current relationship, account and meeting evidence into a concise call brief without inventing intent.","method_outline":["Time-box and date the approved inputs.","Surface objectives, context and honest unknowns.","Draft questions and a read-only brief."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every material point has a source or an unknown label.","The brief does not claim another person's intent."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Prepare a sourced, read-only brief for a person or account call","title":"Call Prep","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Turns current relationship, account and meeting evidence into a concise call brief without inventing intent."},{"availability":"dormant","capability_class":"active-skill","capability_id":"deal-review","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/sales/deal-review/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","manage-tasks-reliably"],"portable_brief":{"goal":"Reviews deal evidence, value coverage and dated activity so pipeline attention goes to the right places.","method_outline":["Read canonical deal values and activity dates.","Keep unchecked and unknown-value deals visible.","Calculate only over a disclosed denominator."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Totals exclude unknown values instead of treating them as zero.","Coverage names checked and unchecked deals."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Review active deals from canonical activity evidence and surface unknowns","title":"Deal Review","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Reviews deal evidence, value coverage and dated activity so pipeline attention goes to the right places."},{"availability":"dormant","capability_class":"active-skill","capability_id":"pipeline-health","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/sales/pipeline-health/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Checks pipeline coverage, stage movement and forecast assumptions against configured sales definitions.","method_outline":["Confirm stages, probabilities, targets and period.","Distinguish missing data from zero.","Show sourced benchmarks, denominators and arithmetic."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every percentage can be recomputed from shown inputs.","Missing configuration returns an unknown result."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Analyze pipeline coverage and forecast confidence from configured sales definitions","title":"Pipeline Health","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Checks pipeline coverage, stage movement and forecast assumptions against configured sales definitions."},{"availability":"dormant","capability_class":"active-skill","capability_id":"customer-intel","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/product/customer-intel/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Synthesizes dated customer evidence into traceable themes while preserving quotes, contradictions and weak-signal limits.","method_outline":["Build a source-ID and date ledger.","Deduplicate repeated evidence without dropping provenance.","Return insufficient evidence when the record cannot support a theme."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Quotes remain faithful to their source.","Contradictory evidence stays visible."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Synthesize recent customer feedback and pain points","title":"Customer Intel","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Synthesizes dated customer evidence into traceable themes while preserving quotes, contradictions and weak-signal limits."},{"availability":"dormant","capability_class":"active-skill","capability_id":"feature-decision","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/product/feature-decision/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Frames an evidence-backed feature recommendation while keeping the human decision and prior record intact.","method_outline":["Gather outcomes, constraints, effort evidence and unknowns.","Compare alternatives and make a labelled recommendation.","Preview a proposed record and preserve or explicitly supersede earlier decisions."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The recommendation is not presented as an accepted decision.","Any persisted record reads back to the confirmed preview."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Framework for making feature prioritization decisions","title":"Feature Decision","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Frames an evidence-backed feature recommendation while keeping the human decision and prior record intact."},{"availability":"dormant","capability_class":"active-skill","capability_id":"roadmap","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/product/roadmap/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","start-each-day-focused"],"portable_brief":{"goal":"Builds a roadmap view from canonical dated status evidence, with disclosed status coverage and honest unknowns.","method_outline":["Read canonical goals, initiatives and status dates.","Keep unknown distinct from blocked.","Reconcile status counts over a declared cohort and cite the evidence."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every status has a source and freshness date.","Excluded or unknown work is shown beside the denominator."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Review roadmap status, evidence freshness, blockers, and alignment","title":"Roadmap","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Builds a roadmap view from canonical dated status evidence, with disclosed status coverage and honest unknowns."},{"availability":"dormant","capability_class":"active-skill","capability_id":"audience-intel","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/marketing/audience-intel/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Finds evidence-backed audience patterns without turning repeated anecdotes into invented personas.","method_outline":["Time-box and deduplicate the evidence ledger.","Compare segments, quotes and contradictions.","Label observed patterns separately from inference."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every audience claim cites quote, source and date.","Insufficient evidence produces an honest limited result."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when synthesizing dated customer conversations, feedback, or behavior evidence into audience or persona insight, especially when sources are numerous, repeated, time-bounded, or disagree.","title":"Audience Intel","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Finds evidence-backed audience patterns without turning repeated anecdotes into invented personas."},{"availability":"dormant","capability_class":"active-skill","capability_id":"campaign-review","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability","context-orientation"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/marketing/campaign-review/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","reflect-and-improve-continuously"],"portable_brief":{"goal":"Turns campaign goals, comparable actuals and attribution limits into reusable learning.","method_outline":["Establish the goal, baseline and comparable period.","Normalize target and actual metrics.","Separate correlation, causation, hypotheses and missing data."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every result cites its source and denominator.","Any saved review is previewed, confirmed and read back."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when a completed or in-flight marketing campaign needs an evidence-backed review of its goal, baseline, targets, actuals, or learnings.","title":"Campaign Review","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Turns campaign goals, comparable actuals and attribution limits into reusable learning."},{"availability":"dormant","capability_class":"active-skill","capability_id":"content-calendar","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/marketing/content-calendar/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","start-each-day-focused"],"portable_brief":{"goal":"Builds a dated content inventory that separates commitments from ideas and exposes collisions, gaps and undated work.","method_outline":["Define the period, timezone and canonical status evidence.","Detect duplicate items and date collisions.","Report committed, idea and undated buckets separately."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["No date, status or coverage percentage is inferred.","Any calendar change requires a confirmed preview."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when inventorying content commitments, ideas, and schedule coverage for a specified period and timezone.","title":"Content Calendar","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Builds a dated content inventory that separates commitments from ideas and exposes collisions, gaps and undated work."},{"availability":"dormant","capability_class":"active-skill","capability_id":"messaging-audit","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","compounding-correctability","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/marketing/messaging-audit/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Compares current messaging with a cited approved baseline and distinguishes drift from intentional variation.","method_outline":["Select and date the canonical baseline.","Normalize terms by audience and channel.","Classify contradictions, intentional variants, stale copy and unsupported claims."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The source-date matrix can be traced to each finding.","No copy is changed without human confirmation."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when comparing product or campaign messaging across content against a cited canonical baseline and its supporting evidence.","title":"Messaging Audit","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Compares current messaging with a cited approved baseline and distinguishes drift from intentional variation."},{"availability":"dormant","capability_class":"active-skill","capability_id":"architecture-decision","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/engineering/architecture-decision/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Compares architecture options and records an accepted choice only after the named human authority decides.","method_outline":["Collect constraints, evidence and alternatives.","Compare consequences and trade-offs.","Keep proposed, accepted and superseded ADR states distinct."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The record names decision authority and sources.","History is appended or superseded, never silently rewritten."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when a system or design choice needs an evidence-backed ADR, explicit alternatives and trade-offs, or review of proposed, accepted, or superseded decision history.","title":"Architecture Decision","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Compares architecture options and records an accepted choice only after the named human authority decides."},{"availability":"dormant","capability_class":"active-skill","capability_id":"incident-review","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability","honest-health-observability","safe-change-recovery"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/engineering/incident-review/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","evolve-the-system-itself","reflect-and-improve-continuously"],"portable_brief":{"goal":"Creates a blameless, evidence-led incident review with a cited timeline and verifiable prevention work.","method_outline":["Build a timezone-aware fact timeline.","Separate facts, hypotheses and contradictions.","Assign prevention actions only from confirmed ownership and proof."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Unknown causes and owners remain explicit.","Follow-up checks name evidence of prevention."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when a service or operational incident needs a cited, timezone-aware timeline, blameless learning review, or prevention actions with accountable follow-up.","title":"Incident Review","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Creates a blameless, evidence-led incident review with a cited timeline and verifiable prevention work."},{"availability":"dormant","capability_class":"active-skill","capability_id":"tech-debt","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/engineering/tech-debt/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","evolve-the-system-itself","start-each-day-focused"],"portable_brief":{"goal":"Creates a deduplicated, evidence-linked technical-debt inventory with honest risk, effort and confidence.","method_outline":["Link code or operational evidence and first-seen dates.","Separate impact, effort, confidence and cost of delay.","Escalate security evidence through the approved path."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Age is never guessed from an undated mention.","Prioritisation retains its evidence and uncertainty."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when technical debt needs linked code or operational evidence, deduplication, first-seen provenance, or impact, effort, confidence, and cost-of-delay prioritization.","title":"Tech Debt","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Creates a deduplicated, evidence-linked technical-debt inventory with honest risk, effort and confidence."},{"availability":"dormant","capability_class":"active-skill","capability_id":"board-prep","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","privacy-minimal-disclosure","scoped-agency-human-control","honest-health-observability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/finance/board-prep/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Builds a reconciled, dated financial narrative and question set as a draft for authorised human review.","method_outline":["Set the as-of date, source hierarchy, unit and currency.","Reconcile actuals and expose forecast limits.","Draft the narrative and likely questions without approving or sending it."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Totals reconcile to cited sources.","Unknowns and forecast assumptions remain visible."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when preparing a finance draft for a board or leadership review from dated actuals, budgets, forecasts, cash data, and decision context. Not for detailed line-item variance analysis; use variance-analysis.","title":"Board Prep","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Builds a reconciled, dated financial narrative and question set as a draft for authorised human review."},{"availability":"dormant","capability_class":"active-skill","capability_id":"close-status","changed_in":[],"compatibility":{"foundation_capabilities":["honest-health-observability","durable-memory-provenance","context-orientation"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/finance/close-status/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","manage-tasks-reliably"],"portable_brief":{"goal":"Shows month-end close progress, blockers and critical path from the authoritative checklist rather than guessed status.","method_outline":["Load the approved checklist and as-of date.","Count complete items over the explicit denominator.","Derive dependencies and critical path while separating blocked, unknown and not started."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Completion can be recomputed from counted evidence.","No missing state becomes complete by inference."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when reporting the evidence-backed status of a named month-end or quarter-end close, its blockers, counted completion, and dependency path. Not for explaining budget variances; use variance-analysis.","title":"Close Status","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Shows month-end close progress, blockers and critical path from the authoritative checklist rather than guessed status."},{"availability":"dormant","capability_class":"active-skill","capability_id":"variance-analysis","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","honest-health-observability","context-orientation"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/finance/variance-analysis/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","reflect-and-improve-continuously"],"portable_brief":{"goal":"Explains reconciled actual-versus-plan differences with validated formulas, materiality and honest causal limits.","method_outline":["Normalize units, signs and comparable periods.","Validate formulas, materiality and reconciled totals.","Label timing or permanent causes as evidenced, hypothesised or unknown."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Shown arithmetic reproduces each variance.","Unsupported causal explanations remain hypotheses."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when explaining a dated actual-versus-budget or actual-versus-forecast variance for a comparable finance period. Not for tracking close checklist completion; use close-status.","title":"Variance Analysis","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Explains reconciled actual-versus-plan differences with validated formulas, materiality and honest causal limits."},{"availability":"dormant","capability_class":"active-skill","capability_id":"expansion-opportunities","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/customer-success/expansion-opportunities/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","track-people-and-relationships"],"portable_brief":{"goal":"Finds account expansion hypotheses while keeping customer evidence, expressed need, fit and speculation separate.","method_outline":["Gather dated account evidence and expressed needs.","Assess fit without inventing value or likelihood.","Keep CRM changes, outreach and commercial action behind human approval."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every hypothesis shows its evidence and confidence.","No recommendation becomes pipeline or customer communication automatically."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when reviewing customer accounts for evidence-backed expansion hypotheses based on current usage, product fit, and expressed needs. Not for renewal strategy or negotiation; use renewal-prep.","title":"Expansion Opportunities","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Finds account expansion hypotheses while keeping customer evidence, expressed need, fit and speculation separate."},{"availability":"dormant","capability_class":"active-skill","capability_id":"health-score","changed_in":[],"compatibility":{"foundation_capabilities":["honest-health-observability","context-orientation","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/customer-success/health-score/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","track-people-and-relationships"],"portable_brief":{"goal":"Applies a configured account-health rubric to dated inputs, or returns not scored when honest scoring is impossible.","method_outline":["Confirm the scoring rubric and data freshness.","Calculate only from permitted dated inputs.","Keep unknown distinct from red or green and review signals when not scored."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The score can be reproduced from the configured rubric.","Silence alone never becomes churn risk."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when reviewing customer-account health with a configured scoring rubric and dated inputs, or when reporting why a portfolio cannot yet be scored. Not for finding expansion opportunities; use expansion-opportunities.","title":"Health Score","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Applies a configured account-health rubric to dated inputs, or returns not scored when honest scoring is impossible."},{"availability":"dormant","capability_class":"active-skill","capability_id":"renewal-prep","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/customer-success/renewal-prep/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","track-people-and-relationships"],"portable_brief":{"goal":"Prepares a sourced renewal brief from contract, ARR, dated outcomes and explicit risks without making commercial commitments.","method_outline":["Cite contract, ARR, renewal date and outcome evidence.","Separate risk from unknown and recommendations from decisions.","Keep pricing and customer communication human-authorised."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every value claim has a dated source.","The brief sends nothing and changes no commercial record."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when preparing an evidence-backed brief for an upcoming customer renewal from contract, ARR, dated outcomes, usage, and risk evidence. Not for health scoring; use health-score.","title":"Renewal Prep","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Prepares a sourced renewal brief from contract, ARR, dated outcomes and explicit risks without making commercial commitments."},{"availability":"dormant","capability_class":"active-skill","capability_id":"metrics-review","changed_in":[],"compatibility":{"foundation_capabilities":["honest-health-observability","context-orientation","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/operations/metrics-review/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","evolve-the-system-itself"],"portable_brief":{"goal":"Reviews comparable operational metrics and validates anomalies before interpreting performance.","method_outline":["Define each metric, unit, window, source, baseline and target.","Check freshness and comparability.","Validate anomalies before offering a non-causal interpretation."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every number has a definition and source date.","Missing or incomparable data stays unknown."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when a business or operational metric needs definition and source provenance checked, freshness and comparability validated, or an anomaly reviewed against a baseline and target.","title":"Metrics Review","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Reviews comparable operational metrics and validates anomalies before interpreting performance."},{"availability":"dormant","capability_class":"active-skill","capability_id":"process-audit","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/operations/process-audit/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","reflect-and-improve-continuously"],"portable_brief":{"goal":"Maps a bounded process from observed samples, then tests bottleneck improvements with measurable outcomes.","method_outline":["Define process start, end, owner and outcome.","Sample observed queues, handoffs, rework and failures.","Propose a controlled experiment with a success measure."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Claims disclose the observed sample and limits.","An experiment is not called successful before measurement."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when an operational process needs its start, end, owner, outcome, representative sample, measured queues or handoffs, bottleneck evidence, or controlled improvement experiment made explicit.","title":"Process Audit","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Maps a bounded process from observed samples, then tests bottleneck improvements with measurable outcomes."},{"availability":"dormant","capability_class":"active-skill","capability_id":"design-review","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/design/design-review/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Prepares or documents a design review with versioned artifacts, traceable requirements and explicit decision authority.","method_outline":["Choose preparation or documentation mode.","Identify artifact versions, requirements and evidence.","Keep recommendations distinct from authorised decisions."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every finding points to a versioned artifact and requirement.","A decision record names who accepted it."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when a design artifact or revision needs a prepared review packet or an evidence-backed record of a review outcome, requirements, and decisions.","title":"Design Review","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Prepares or documents a design review with versioned artifacts, traceable requirements and explicit decision authority."},{"availability":"dormant","capability_class":"active-skill","capability_id":"design-system-audit","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/design/design-system-audit/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","evolve-the-system-itself"],"portable_brief":{"goal":"Measures design-system use against canonical components and tokens with a declared sample and denominator.","method_outline":["Select canonical components, tokens and a representative sample.","Calculate adoption over a disclosed denominator.","Separate accidental deviations from intentional exceptions."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Coverage and adoption can be recomputed from shown inputs.","Exceptions retain owner, reason and evidence."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when assessing use of named design-system components or tokens across a defined sample of product artifacts, including adoption and deviation questions.","title":"Design System Audit","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Measures design-system use against canonical components and tokens with a declared sample and denominator."},{"availability":"dormant","capability_class":"active-skill","capability_id":"career-setup","changed_in":[],"compatibility":{"foundation_capabilities":["privacy-minimal-disclosure","ownership-portability","scoped-agency-human-control","safe-change-recovery"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","career-room-enabled","room-capability-manager"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":true,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions close the reviewed evidence, authority and recovery gaps."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_capabilities.py","summary":"Room activation verifies release-owned skill identity before changing profile or files."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/capabilities/career/skills/career-setup/SKILL.md","summary":"The release ships this room skill as the source used when the room is enabled."}],"impact_tier":"high","jobs":["track-career-growth"],"portable_brief":{"goal":"Sets up the career room and its consented evidence space while verifying the room, hooks and connected tools honestly.","method_outline":["Preview the canonical career evidence paths and sensitive-data boundary.","Enable only after consent.","Verify room, hook and MCP state and surface capture failures."],"rollback_advice":"Disable the room through the capability manager; preserve the person's room content and remove only release-owned surfaced skill copies.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["All evidence paths use the portable room contract.","Failed setup leaves a clear recovery state."]},"prerequisites":["Enable the career room; its skills are installed as one room bundle, not adopted independently.","Keep the room's approved source and privacy boundaries available to the host."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Initialize career development system (job description, ladder, reviews, goals)","title":"Career Setup","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Sets up the career room and its consented evidence space while verifying the room, hooks and connected tools honestly."},{"availability":"dormant","capability_class":"active-skill","capability_id":"career-coach","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","compounding-correctability","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","career-room-enabled","room-capability-manager"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions close the reviewed evidence, authority and recovery gaps."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_capabilities.py","summary":"Room activation verifies release-owned skill identity before changing profile or files."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/capabilities/career/skills/career-coach/SKILL.md","summary":"The release ships this room skill as the source used when the room is enabled."}],"impact_tier":"high","jobs":["track-career-growth","reflect-and-improve-continuously"],"portable_brief":{"goal":"Turns sourced career evidence into reflective coaching while keeping uncertainty, HR limits and save consent explicit.","method_outline":["Choose the coaching mode and inspect consented evidence.","Separate missing evidence from missing competency and label confidence.","Preview and confirm any saved reflection."],"rollback_advice":"Disable the room through the capability manager; preserve the person's room content and remove only release-owned surfaced skill copies.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Claims cite evidence and uncertainty.","The coach does not impersonate HR or a manager."]},"prerequisites":["Enable the career room; its skills are installed as one room bundle, not adopted independently.","Keep the room's approved source and privacy boundaries available to the host."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Personal career coach with 4 modes: weekly reports, monthly reflections, self-reviews, promotion assessments","title":"Career Coach","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Turns sourced career evidence into reflective coaching while keeping uncertainty, HR limits and save consent explicit."},{"availability":"dormant","capability_class":"active-skill","capability_id":"resume-builder","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","privacy-minimal-disclosure","ownership-portability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","career-room-enabled","room-capability-manager"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions close the reviewed evidence, authority and recovery gaps."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_capabilities.py","summary":"Room activation verifies release-owned skill identity before changing profile or files."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/capabilities/career/skills/resume-builder/SKILL.md","summary":"The release ships this room skill as the source used when the room is enabled."}],"impact_tier":"high","jobs":["track-career-growth"],"portable_brief":{"goal":"Builds a truthful, portable resume from sourced evidence and verifies the rendered result before claiming pagination.","method_outline":["Gather cited outcomes without inventing metrics.","Label any user-supplied estimate.","Render-check pages and separately confirm every cross-file write."],"rollback_advice":"Disable the room through the capability manager; preserve the person's room content and remove only release-owned surfaced skill copies.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every claim maps to evidence or an explicit supplied estimate.","Pagination is claimed only after rendering."]},"prerequisites":["Enable the career room; its skills are installed as one room bundle, not adopted independently.","Keep the room's approved source and privacy boundaries available to the host."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Build resume and LinkedIn profile through guided interview","title":"Resume Builder","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Builds a truthful, portable resume from sourced evidence and verifies the rendered result before claiming pagination."},{"availability":"dormant","capability_class":"active-skill","capability_id":"quarter-plan","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control","safe-change-recovery"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","quarter-goals-room-enabled","room-capability-manager"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions close the reviewed evidence, authority and recovery gaps."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_capabilities.py","summary":"Room activation verifies release-owned skill identity before changing profile or files."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/capabilities/quarter_goals/skills/quarter-plan/SKILL.md","summary":"The release ships this room skill as the source used when the room is enabled."}],"impact_tier":"high","jobs":["start-each-day-focused"],"portable_brief":{"goal":"Builds a quarter plan across the correct fiscal boundary with previewed, conflict-safe and verified writes.","method_outline":["Confirm fiscal-quarter dates and current goals.","Preview every archive, move or goal mutation separately.","Preserve conflicting bytes and read back approved results."],"rollback_advice":"Disable the room through the capability manager; preserve the person's room content and remove only release-owned surfaced skill copies.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["No mutation occurs without its exact confirmation.","Conflicts preserve the existing file and report recovery."]},"prerequisites":["Enable the quarter goals room; its skills are installed as one room bundle, not adopted independently.","Keep the room's approved source and privacy boundaries available to the host."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Set 3-5 strategic goals for the quarter","title":"Quarter Plan","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Builds a quarter plan across the correct fiscal boundary with previewed, conflict-safe and verified writes."},{"availability":"dormant","capability_class":"active-skill","capability_id":"quarter-review","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","compounding-correctability","honest-health-observability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","quarter-goals-room-enabled","room-capability-manager"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions close the reviewed evidence, authority and recovery gaps."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_capabilities.py","summary":"Room activation verifies release-owned skill identity before changing profile or files."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/capabilities/quarter_goals/skills/quarter-review/SKILL.md","summary":"The release ships this room skill as the source used when the room is enabled."}],"impact_tier":"high","jobs":["start-each-day-focused","reflect-and-improve-continuously"],"portable_brief":{"goal":"Reviews a quarter from sourced statistics and reflections without inferring completion or chaining unapproved mutations.","method_outline":["Source every statistic and expose unknowns.","Keep reflection, archive and next-plan changes under separate consent.","Make archive recovery idempotent and never infer completion percentages."],"rollback_advice":"Disable the room through the capability manager; preserve the person's room content and remove only release-owned surfaced skill copies.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every statistic has a source and denominator.","A repeated archive action cannot duplicate or overwrite work."]},"prerequisites":["Enable the quarter goals room; its skills are installed as one room bundle, not adopted independently.","Keep the room's approved source and privacy boundaries available to the host."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Review quarter completion and capture learnings","title":"Quarter Review","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Reviews a quarter from sourced statistics and reflections without inferring completion or chaining unapproved mutations."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-analytics","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/analytics_server.py","summary":"The shipped source tree contains the reviewed Dex Analytics implementation."}],"example_tools":["check_analytics_status","identify_user","test_connection","track_event"],"impact_tier":"medium","jobs":["reflect-and-improve-continuously"],"prerequisites":["The Dex analytics MCP server is registered locally."],"release_provenance":"core-release","server_name":"dex-analytics","source_paths":["core/mcp/analytics_server.py"],"summary":"dex-analytics exposes 4 local MCP tools; examples include check_analytics_status, identify_user, test_connection, track_event.","title":"Dex Analytics","tool_count":4,"trade_offs":["Usage signals are only as complete as the events the local system records."],"value":"Shows which Dex workflows are being used so the system can improve from real behavior."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-calendar-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/calendar_server.py","summary":"The shipped source tree contains the reviewed Dex Calendar MCP implementation."}],"example_tools":["calendar_create_event","calendar_delete_event","calendar_get_events","calendar_get_events_with_attendees","calendar_get_next_event"],"impact_tier":"high","jobs":["start-each-day-focused","track-people-and-relationships"],"prerequisites":["Local calendar access is authorized and the server is registered."],"release_provenance":"core-release","server_name":"dex-calendar-mcp","source_paths":["core/mcp/calendar_server.py"],"summary":"dex-calendar-mcp exposes 15 local MCP tools; examples include calendar_create_event, calendar_delete_event, calendar_get_events, calendar_get_events_with_attendees, calendar_get_next_event.","title":"Dex Calendar MCP","tool_count":15,"trade_offs":["Calendar results depend on operating-system permissions and the freshness of local calendars."],"value":"Makes calendar pressure and meeting context available to planning and preparation workflows."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-career-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/career_server.py","summary":"The shipped source tree contains the reviewed Dex Career MCP implementation."}],"example_tools":["analyze_coverage","generate_evidence_from_work","parse_ladder","promotion_readiness_score","scan_evidence"],"impact_tier":"medium","jobs":["track-career-growth"],"prerequisites":["The career capability is enabled and its local data paths exist."],"release_provenance":"core-release","server_name":"dex-career-mcp","source_paths":["core/mcp/career_server.py"],"summary":"dex-career-mcp exposes 8 local MCP tools; examples include analyze_coverage, generate_evidence_from_work, parse_ladder, promotion_readiness_score, scan_evidence.","title":"Dex Career MCP","tool_count":8,"trade_offs":["Career outputs remain bounded by the evidence the person has chosen to capture."],"value":"Keeps career evidence and development work consented, sourced and reviewable."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-customization-migration-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/customization_migration_server.py","summary":"The shipped source tree contains the reviewed Dex Customization Migration MCP implementation."}],"example_tools":["assess_customizations","preview_customization_capsule","read_activation_status","read_customization_capsule_blob","read_customization_capsule_section"],"impact_tier":"medium","jobs":["evolve-the-system-itself"],"prerequisites":["A compatible migration plan and lifecycle service are available."],"release_provenance":"core-release","server_name":"dex-customization-migration-mcp","source_paths":["core/mcp/customization_migration_server.py"],"summary":"dex-customization-migration-mcp exposes 7 local MCP tools; examples include assess_customizations, preview_customization_capsule, read_activation_status, read_customization_capsule_blob, read_customization_capsule_section.","title":"Dex Customization Migration MCP","tool_count":7,"trade_offs":["Migration remains confirm-gated and may refuse changes that cannot be safely reversed."],"value":"Moves approved customizations through Dex's receipt-backed lifecycle instead of editing the vault ad hoc."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-granola-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/granola_server.py","summary":"The shipped source tree contains the reviewed Dex Granola MCP implementation."}],"example_tools":["granola_check_available","granola_get_extent","granola_get_meeting_details","granola_get_recent_meetings","granola_get_today_meetings"],"impact_tier":"high","jobs":["capture-without-friction","track-people-and-relationships"],"prerequisites":["Granola access is connected and authorized by the person."],"release_provenance":"core-release","server_name":"dex-granola-mcp","source_paths":["core/mcp/granola_server.py"],"summary":"dex-granola-mcp exposes 6 local MCP tools; examples include granola_check_available, granola_get_extent, granola_get_meeting_details, granola_get_recent_meetings, granola_get_today_meetings.","title":"Dex Granola MCP","tool_count":6,"trade_offs":["Meeting coverage depends on the upstream Granola account and transcript availability."],"value":"Brings meeting records into Dex for processing without relying on manual transcript copying."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-improvements-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/dex_improvements_server.py","summary":"The shipped source tree contains the reviewed Dex Improvements MCP implementation."}],"example_tools":["capture_idea","enrich_idea","get_backlog_stats","get_idea_details","list_ideas"],"impact_tier":"high","jobs":["reflect-and-improve-continuously","evolve-the-system-itself"],"prerequisites":["The local improvements store is available."],"release_provenance":"core-release","server_name":"dex-improvements-mcp","source_paths":["core/mcp/dex_improvements_server.py"],"summary":"dex-improvements-mcp exposes 9 local MCP tools; examples include capture_idea, enrich_idea, get_backlog_stats, get_idea_details, list_ideas.","title":"Dex Improvements MCP","tool_count":9,"trade_offs":["Ranking is advisory and still needs a person to choose what should change."],"value":"Turns observed friction into a ranked, inspectable backlog of system improvements."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-onboarding-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/onboarding_server.py","summary":"The shipped source tree contains the reviewed Dex Onboarding MCP implementation."}],"example_tools":["apply_confirmed_onboarding_context","check_onboarding_complete","cleanup_qa_session","finalize_onboarding","generate_nudge_calendar"],"impact_tier":"high","jobs":["evolve-the-system-itself"],"prerequisites":["Dex is running from a writable local vault during onboarding."],"release_provenance":"core-release","server_name":"dex-onboarding-mcp","source_paths":["core/mcp/onboarding_server.py"],"summary":"dex-onboarding-mcp exposes 19 local MCP tools; examples include apply_confirmed_onboarding_context, check_onboarding_complete, cleanup_qa_session, finalize_onboarding, generate_nudge_calendar.","title":"Dex Onboarding MCP","tool_count":19,"trade_offs":["Setup quality depends on the person supplying accurate preferences and granting chosen permissions."],"value":"Coordinates first-run setup through explicit, locally verified onboarding steps."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-pipedrive-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/integrations/pipedrive/pipedrive_server.py","summary":"The shipped source tree contains the reviewed Dex Pipedrive MCP implementation."}],"example_tools":["pipedrive_add_deal_activity","pipedrive_add_deal_note","pipedrive_create_deal","pipedrive_create_org","pipedrive_find_deal"],"impact_tier":"high","jobs":["keep-projects-on-track","track-people-and-relationships"],"prerequisites":["Pipedrive is explicitly connected and its local server is registered."],"release_provenance":"core-release","server_name":"dex-pipedrive-mcp","source_paths":["core/integrations/pipedrive/pipedrive_server.py"],"summary":"dex-pipedrive-mcp exposes 15 local MCP tools; examples include pipedrive_add_deal_activity, pipedrive_add_deal_note, pipedrive_create_deal, pipedrive_create_org, pipedrive_find_deal.","title":"Dex Pipedrive MCP","tool_count":15,"trade_offs":["External records depend on Pipedrive availability, and writes remain opt-in and confirmation-gated."],"value":"Connects customer relationship data to Dex so deal context can support planning and follow-through."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-resume-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/resume_server.py","summary":"The shipped source tree contains the reviewed Dex Resume MCP implementation."}],"example_tools":["add_role","compile_resume","export_resume","extract_achievements","generate_linkedin"],"impact_tier":"medium","jobs":["track-career-growth"],"prerequisites":["Consented career evidence exists in the local career space."],"release_provenance":"core-release","server_name":"dex-resume-mcp","source_paths":["core/mcp/resume_server.py"],"summary":"dex-resume-mcp exposes 12 local MCP tools; examples include add_role, compile_resume, export_resume, extract_achievements, generate_linkedin.","title":"Dex Resume MCP","tool_count":12,"trade_offs":["The server cannot fill evidence gaps without the person's review and additional source material."],"value":"Builds truthful application material from consented career evidence rather than invented claims."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-session-memory","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/session_memory_server.py","summary":"The shipped source tree contains the reviewed Dex Session Memory implementation."}],"example_tools":["get_entity_timeline","get_observation_timeline","get_recent_decisions","get_recent_tool_usage","get_session_context"],"impact_tier":"high","jobs":["reflect-and-improve-continuously","keep-projects-on-track"],"prerequisites":["The local session-memory store is available."],"release_provenance":"core-release","server_name":"dex-session-memory","source_paths":["core/mcp/session_memory_server.py"],"summary":"dex-session-memory exposes 8 local MCP tools; examples include get_entity_timeline, get_observation_timeline, get_recent_decisions, get_recent_tool_usage, get_session_context.","title":"Dex Session Memory","tool_count":8,"trade_offs":["Remembered context can become stale and must retain clear provenance."],"value":"Carries sourced context across sessions so repeated work does not restart from an empty chat."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-work-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/work_server.py","summary":"The shipped source tree contains the reviewed Dex Work MCP implementation."}],"example_tools":["analyze_calendar_capacity","boot_today","build_company_index","build_people_index","capture_skill_rating"],"impact_tier":"core","jobs":["manage-tasks-reliably","keep-projects-on-track","track-people-and-relationships"],"prerequisites":["A Dex vault and its portable path contract are available."],"release_provenance":"core-release","server_name":"dex-work-mcp","source_paths":["core/mcp/work_server.py"],"summary":"dex-work-mcp exposes 53 local MCP tools; examples include analyze_calendar_capacity, boot_today, build_company_index, build_people_index, capture_skill_rating.","title":"Dex Work MCP","tool_count":53,"trade_offs":["Mutations remain bounded by confirmation, validation and the local vault's current structure."],"value":"Provides the validated task, project, person and company operations that core Dex workflows rely on."},{"automation_label":"com.dex.changelog-checker","availability":"active","cadence":"every 6 hours; also at load","capability_class":"scheduled-automation","capability_id":"dex-changelog-checker","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: .scripts/com.dex.changelog-checker.plist","summary":"The shipped source tree contains the reviewed Dex Changelog Checker implementation."}],"impact_tier":"medium","installer_path":".scripts/install-learning-automation.sh","jobs":["evolve-the-system-itself"],"prerequisites":["The learning automation launch agent is installed on macOS."],"program_target":"{{VAULT_PATH}}/.scripts/check-anthropic-changelog.cjs","release_provenance":"core-release","run_at_load":true,"source_paths":[".scripts/com.dex.changelog-checker.plist",".scripts/install-learning-automation.sh"],"summary":"Runs {{VAULT_PATH}}/.scripts/check-anthropic-changelog.cjs every 6 hours; also at load.","title":"Dex Changelog Checker","trade_offs":["The check is periodic, so upstream changes are not surfaced instantly."],"value":"Checks for relevant upstream capability changes several times a day without manual polling."},{"automation_label":"com.dex.learning-review","availability":"active","cadence":"daily at 17:00","capability_class":"scheduled-automation","capability_id":"dex-learning-review","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: .scripts/com.dex.learning-review.plist","summary":"The shipped source tree contains the reviewed Dex Learning Review implementation."}],"impact_tier":"high","installer_path":".scripts/install-learning-automation.sh","jobs":["reflect-and-improve-continuously"],"prerequisites":["The learning automation launch agent is installed on macOS."],"program_target":"{{VAULT_PATH}}/.scripts/learning-review-prompt.sh","release_provenance":"core-release","run_at_load":false,"source_paths":[".scripts/com.dex.learning-review.plist",".scripts/install-learning-automation.sh"],"summary":"Runs {{VAULT_PATH}}/.scripts/learning-review-prompt.sh daily at 17:00.","title":"Dex Learning Review","trade_offs":["A scheduled prompt still depends on the person choosing to review and adopt useful changes."],"value":"Prompts a daily review so observed friction can become durable learning."},{"automation_label":"com.dex.meeting-intel","availability":"active","cadence":"every 30 minutes; also at load","capability_class":"scheduled-automation","capability_id":"dex-meeting-intel","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: .scripts/meeting-intel/com.dex.meeting-intel.plist.template","summary":"The shipped source tree contains the reviewed Dex Meeting Intel implementation."}],"impact_tier":"high","installer_path":".scripts/meeting-intel/install-automation.sh","jobs":["capture-without-friction","track-people-and-relationships"],"prerequisites":["Granola is connected and the meeting-intelligence launch agent is installed on macOS."],"program_target":".scripts/meeting-intel/sync-from-granola.cjs","release_provenance":"core-release","run_at_load":true,"source_paths":[".scripts/meeting-intel/com.dex.meeting-intel.plist.template",".scripts/meeting-intel/install-automation.sh"],"summary":"Runs .scripts/meeting-intel/sync-from-granola.cjs every 30 minutes; also at load.","title":"Dex Meeting Intel","trade_offs":["Sync freshness depends on both the upstream service and the local machine being able to run the job."],"value":"Keeps Granola meeting material synchronized frequently enough for timely preparation and closeout."},{"automation_label":"com.dex.smoke-nightly","availability":"active","cadence":"daily at 03:15","capability_class":"scheduled-automation","capability_id":"dex-smoke-nightly","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: .scripts/com.dex.smoke-nightly.plist.template","summary":"The shipped source tree contains the reviewed Dex Smoke Nightly implementation."}],"impact_tier":"high","installer_path":".scripts/install-smoke-automation.sh","jobs":["evolve-the-system-itself"],"prerequisites":["The nightly smoke launch agent is installed on macOS."],"program_target":"__VAULT_PATH__/.scripts/nightly-smoke.sh","release_provenance":"core-release","run_at_load":false,"source_paths":[".scripts/com.dex.smoke-nightly.plist.template",".scripts/install-smoke-automation.sh"],"summary":"Runs __VAULT_PATH__/.scripts/nightly-smoke.sh daily at 03:15.","title":"Dex Smoke Nightly","trade_offs":["A nightly check can detect known failures but cannot prove every workflow is healthy."],"value":"Runs a nightly health smoke check so breakage can surface before a person depends on the system."},{"automation_label":"com.dex.vault-backup","availability":"active","cadence":"daily at a user-selected time","capability_class":"scheduled-automation","capability_id":"dex-vault-backup","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/backup/install_backup_job.py","summary":"The shipped source tree contains the reviewed Dex Vault Backup implementation."}],"impact_tier":"core","installer_path":"core/backup/install_backup_job.py","jobs":["evolve-the-system-itself"],"prerequisites":["Backup setup is complete and its destination has been verified."],"program_target":"core/backup/backup_vault.py","release_provenance":"core-release","run_at_load":false,"source_paths":["core/backup/install_backup_job.py","core/backup/backup_vault.py"],"summary":"Runs core/backup/backup_vault.py daily at a user-selected time.","title":"Dex Vault Backup","trade_offs":["A schedule is not proof of recovery; the person must still test that a backup can be restored."],"value":"Creates a scheduled recovery copy of the person's vault at a time they choose."},{"availability":"parked","capability_class":"system-engine","capability_id":"connection-manager-engine","component_count":20,"evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/integrations/connection-manager/auth-context.cjs","summary":"The shipped source tree contains the reviewed Connection Manager Engine implementation."}],"example_components":["core/integrations/connection-manager/auth-context.cjs","core/integrations/connection-manager/broker-client.cjs","core/integrations/connection-manager/broker.cjs","core/integrations/connection-manager/catalog.cjs","core/integrations/connection-manager/connect.cjs"],"impact_tier":"high","jobs":["evolve-the-system-itself"],"prerequisites":["A reviewed person-facing doorway must be released before this engine can be used."],"release_provenance":"core-release","source_paths":["core/integrations/connection-manager/auth-context.cjs","core/integrations/connection-manager/broker-client.cjs","core/integrations/connection-manager/broker.cjs","core/integrations/connection-manager/catalog.cjs","core/integrations/connection-manager/connect.cjs","core/integrations/connection-manager/contract.cjs","core/integrations/connection-manager/dex-call.cjs","core/integrations/connection-manager/fs-safe.cjs","core/integrations/connection-manager/get-token.cjs","core/integrations/connection-manager/health.cjs","core/integrations/connection-manager/index.cjs","core/integrations/connection-manager/lib/connector-ledger.js","core/integrations/connection-manager/lib/connector-model.js","core/integrations/connection-manager/lib/connector-verify.js","core/integrations/connection-manager/lib/oauth-refresh.js","core/integrations/connection-manager/lib/rate-limit.js","core/integrations/connection-manager/oauth-flow.cjs","core/integrations/connection-manager/pinned-providers.cjs","core/integrations/connection-manager/presence.cjs","core/integrations/connection-manager/token-store.cjs"],"summary":"Groups 20 shipped source components. Parked: it is not wired into the live product.","title":"Connection Manager Engine","trade_offs":["The engine is shipped groundwork and must not be recommended as currently usable."],"value":"Provides local connection custody and provider metadata, but its person-facing doorway remains unavailable."},{"availability":"active","capability_class":"system-engine","capability_id":"entity-temperature-engine","component_count":9,"evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/entity_engine/__init__.py","summary":"The shipped source tree contains the reviewed Entity Temperature Engine implementation."}],"example_components":["core/entity_engine/__init__.py","core/entity_engine/cli.py","core/entity_engine/contract.py","core/entity_engine/cooling.py","core/entity_engine/index.py"],"impact_tier":"high","jobs":["track-people-and-relationships"],"prerequisites":["Entity indexing and relationship data are available locally."],"release_provenance":"core-release","source_paths":["core/entity_engine/__init__.py","core/entity_engine/cli.py","core/entity_engine/contract.py","core/entity_engine/cooling.py","core/entity_engine/index.py","core/entity_engine/relationships.py","core/entity_engine/reroute.py","core/entity_engine/temperature.py","core/entity_engine/write.py"],"summary":"Groups 9 shipped source components.","title":"Entity Temperature Engine","trade_offs":["Temperature is a prioritization signal, not an objective measure of relationship importance."],"value":"Keeps people and entity context warm when it matters and cools stale signals over time."},{"availability":"active","capability_class":"system-engine","capability_id":"proactive-promise-engine","component_count":2,"evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/health/promises.py","summary":"The shipped source tree contains the reviewed Proactive Promise Engine implementation."}],"example_components":["core/health/promises.py","core/tests/test_health_promises.py"],"impact_tier":"core","jobs":["manage-tasks-reliably","evolve-the-system-itself"],"prerequisites":["Dex Doctor can inspect the relevant local runtime evidence."],"release_provenance":"core-release","source_paths":["core/health/promises.py","core/tests/test_health_promises.py"],"summary":"Groups 2 shipped source components.","title":"Proactive Promise Engine","trade_offs":["A promise only detects the failure modes its evidence and thresholds explicitly cover."],"value":"Defines the concrete promises Dex health checks use to catch silent reliability failures."},{"availability":"parked","capability_class":"system-engine","capability_id":"ritual-intelligence-engine","component_count":22,"evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/ritual_intelligence/__init__.py","summary":"The shipped source tree contains the reviewed Ritual Intelligence Engine implementation."}],"example_components":["core/ritual_intelligence/__init__.py","core/ritual_intelligence/__main__.py","core/ritual_intelligence/actions.py","core/ritual_intelligence/brief_generate.py","core/ritual_intelligence/calendar_ingest.py"],"impact_tier":"high","jobs":["start-each-day-focused","capture-without-friction"],"prerequisites":["The parked engine would need an approved live integration before it could serve users."],"release_provenance":"core-release","source_paths":["core/ritual_intelligence/__init__.py","core/ritual_intelligence/__main__.py","core/ritual_intelligence/actions.py","core/ritual_intelligence/brief_generate.py","core/ritual_intelligence/calendar_ingest.py","core/ritual_intelligence/cli.py","core/ritual_intelligence/contact_promote.py","core/ritual_intelligence/contact_suggest.py","core/ritual_intelligence/corrections.py","core/ritual_intelligence/db.py","core/ritual_intelligence/manual_note_match.py","core/ritual_intelligence/matching.py","core/ritual_intelligence/meeting_intel_projection.py","core/ritual_intelligence/meeting_reconcile.py","core/ritual_intelligence/models.py","core/ritual_intelligence/prep_state.py","core/ritual_intelligence/projection_write.py","core/ritual_intelligence/ritual_match.py","core/ritual_intelligence/service.py","core/ritual_intelligence/transcript_ingest.py","core/ritual_intelligence/transcript_reconcile.py","core/ritual_intelligence/transcript_store.py"],"summary":"Groups 22 shipped source components. Parked: it is not wired into the live product.","title":"Ritual Intelligence Engine","trade_offs":["This capability is parked and must not be presented as currently available."],"value":"Contains a richer meeting and ritual intelligence engine that is code-complete but not wired into the live product."},{"availability":"active","capability_class":"system-engine","capability_id":"session-hook-orchestration","component_count":32,"evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: .claude/hooks/README.md","summary":"The shipped source tree contains the reviewed Session Hook Orchestration implementation."}],"example_components":[".claude/hooks/README.md",".claude/hooks/adapters/jira.cjs",".claude/hooks/adapters/run.cjs",".claude/hooks/adapters/service-aliases.json",".claude/hooks/adapters/things.cjs"],"impact_tier":"core","jobs":["evolve-the-system-itself","start-each-day-focused"],"prerequisites":["Claude Code hooks are installed and enabled for the Dex vault."],"release_provenance":"core-release","source_paths":[".claude/hooks/README.md",".claude/hooks/adapters/jira.cjs",".claude/hooks/adapters/run.cjs",".claude/hooks/adapters/service-aliases.json",".claude/hooks/adapters/things.cjs",".claude/hooks/adapters/todoist.cjs",".claude/hooks/adapters/trello.cjs",".claude/hooks/career-evidence-capture.cjs",".claude/hooks/claude-composition-refresh.sh",".claude/hooks/company-context-injector.cjs",".claude/hooks/connection-health-checker.cjs",".claude/hooks/correction-capture.py",".claude/hooks/correction-capture.sh",".claude/hooks/daily-plan-quick-ref.cjs",".claude/hooks/dex-core-orientation.sh",".claude/hooks/dex-safety-guard.sh",".claude/hooks/ensure-mcp-user-scope.cjs",".claude/hooks/health-pulse.sh",".claude/hooks/integration-concierge.cjs",".claude/hooks/maintenance.cjs",".claude/hooks/meeting-cache-builder.cjs",".claude/hooks/meeting-queue-check.cjs",".claude/hooks/observation-recorder.py",".claude/hooks/paths.cjs",".claude/hooks/person-context-injector.cjs",".claude/hooks/post-meeting-person-update.cjs",".claude/hooks/session-clock.sh",".claude/hooks/session-end.sh",".claude/hooks/session-start.sh",".claude/hooks/skill-freshness.py",".claude/hooks/soft-promise-detector.py",".claude/hooks/vault-autocommit.cjs"],"summary":"Groups 32 shipped source components.","title":"Session Hook Orchestration","trade_offs":["Hook behavior depends on the host honoring the configured lifecycle events and local permissions."],"value":"Coordinates session startup, safety, context injection, maintenance and closeout around the user's work."}],"capability_families":[{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"dex-granola-mcp","component_type":"capability"},{"capability_id":"dex-meeting-intel","component_type":"capability"},{"capability_id":"granola-setup","component_type":"capability"},{"capability_id":"meeting-closeout","component_type":"capability"},{"capability_id":"meeting-prep","component_type":"capability"},{"capability_id":"process-meetings","component_type":"capability"}],"family_id":"meeting-follow-through","jobs":["capture-without-friction","track-people-and-relationships"],"member_capability_ids":["dex-granola-mcp","dex-meeting-intel","granola-setup","meeting-closeout","meeting-prep","process-meetings"],"outcome":"Meetings become notes, people context and tracked follow-up.","title":"Meeting follow-through"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"entity-temperature-engine","component_type":"capability"},{"capability_id":"relationship-radar","component_type":"capability"}],"family_id":"living-people-company-context","jobs":["track-people-and-relationships"],"member_capability_ids":["entity-temperature-engine","relationship-radar"],"outcome":"People and company pages are created, refreshed and connected over time.","title":"Living people and company context"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"commitments","component_type":"capability"},{"capability_id":"delegate-check","component_type":"capability"},{"capability_id":"dex-work-mcp","component_type":"capability"},{"capability_id":"proactive-promise-engine","component_type":"capability"},{"capability_id":"triage","component_type":"capability"}],"family_id":"durable-task-continuity","jobs":["evolve-the-system-itself","keep-projects-on-track","manage-tasks-reliably","track-people-and-relationships"],"member_capability_ids":["commitments","delegate-check","dex-work-mcp","proactive-promise-engine","triage"],"outcome":"Tasks can be captured from several places and completion returns to linked surfaces.","title":"Durable task continuity"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"things-setup","component_type":"capability"},{"capability_id":"todoist-setup","component_type":"capability"},{"capability_id":"trello-setup","component_type":"capability"}],"family_id":"external-task-interoperability","jobs":["manage-tasks-reliably"],"member_capability_ids":["things-setup","todoist-setup","trello-setup"],"outcome":"Todoist, Things and Trello can exchange tasks on request without pretending background polling exists.","title":"External task interoperability"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"apple-mail-setup","component_type":"capability"},{"capability_id":"atlassian-setup","component_type":"capability"},{"capability_id":"calendar-setup","component_type":"capability"},{"capability_id":"dex-calendar-mcp","component_type":"capability"},{"capability_id":"google-workspace-setup","component_type":"capability"},{"capability_id":"ms-teams-setup","component_type":"capability"},{"capability_id":"zoom-setup","component_type":"capability"}],"family_id":"connected-work-context","jobs":["capture-without-friction","keep-projects-on-track","start-each-day-focused","track-people-and-relationships"],"member_capability_ids":["apple-mail-setup","atlassian-setup","calendar-setup","dex-calendar-mcp","google-workspace-setup","ms-teams-setup","zoom-setup"],"outcome":"Google, Teams, Zoom, Atlassian and Apple Mail can inform plans, preparation and reviews when explicitly connected.","title":"Connected work context"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"dex-pipedrive-mcp","component_type":"capability"},{"capability_id":"pipedrive-setup","component_type":"capability"},{"capability_id":"pipeline-sync","component_type":"capability"}],"family_id":"pipedrive-pipeline-continuity","jobs":["keep-projects-on-track","track-people-and-relationships"],"member_capability_ids":["dex-pipedrive-mcp","pipedrive-setup","pipeline-sync"],"outcome":"Live pipeline context informs local work; external writes stay previewed and confirmed.","title":"Pipedrive pipeline continuity"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"daily-plan","component_type":"capability"},{"capability_id":"daily-review","component_type":"capability"},{"capability_id":"week-plan","component_type":"capability"},{"capability_id":"week-review","component_type":"capability"},{"capability_id":"weekly-reflection","component_type":"capability"}],"family_id":"daily-weekly-operating-rhythm","jobs":["reflect-and-improve-continuously","start-each-day-focused"],"member_capability_ids":["daily-plan","daily-review","week-plan","week-review","weekly-reflection"],"outcome":"Planning, review and reflection form one repeatable operating cadence.","title":"Daily and weekly operating rhythm"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"decision-log","component_type":"capability"},{"capability_id":"dex-session-memory","component_type":"capability"},{"capability_id":"enable-semantic-search","component_type":"capability"},{"capability_id":"journal","component_type":"capability"},{"capability_id":"save-insight","component_type":"capability"}],"family_id":"durable-work-memory","jobs":["keep-projects-on-track","reflect-and-improve-continuously"],"member_capability_ids":["decision-log","dex-session-memory","enable-semantic-search","journal","save-insight"],"outcome":"Sourced decisions, commitments, context and patterns remain available across sessions.","title":"Durable work memory"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"dex-doctor","component_type":"capability"},{"capability_id":"dex-smoke-nightly","component_type":"capability"}],"family_id":"proactive-health-and-recovery","jobs":["evolve-the-system-itself"],"member_capability_ids":["dex-doctor","dex-smoke-nightly"],"outcome":"Doctor and scheduled checks distinguish healthy, off, broken and unknown, then use bounded repair paths.","title":"Proactive health and recovery"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"backup-now","component_type":"capability"},{"capability_id":"backup-restore","component_type":"capability"},{"capability_id":"backup-setup","component_type":"capability"},{"capability_id":"dex-vault-backup","component_type":"capability"}],"family_id":"backup-and-restore-confidence","jobs":["evolve-the-system-itself"],"member_capability_ids":["backup-now","backup-restore","backup-setup","dex-vault-backup"],"outcome":"Backups are created and recovery is proved by a safe restore rehearsal.","title":"Backup and restore confidence"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"dex-rollback","component_type":"capability"},{"capability_id":"dex-update","component_type":"capability"},{"capability_id":"diff-adopt","component_type":"capability"},{"capability_id":"diff-adopt-profile","component_type":"capability"},{"capability_id":"diff-generate","component_type":"capability"},{"capability_id":"diff-list","component_type":"capability"},{"capability_id":"diff-profile","component_type":"capability"},{"capability_id":"diff-remove","component_type":"capability"}],"family_id":"safe-change-and-rewind","jobs":["evolve-the-system-itself","reflect-and-improve-continuously"],"member_capability_ids":["dex-rollback","dex-update","diff-adopt","diff-adopt-profile","diff-generate","diff-list","diff-profile","diff-remove"],"outcome":"Changes are previewed, verified, receipted and reversible.","title":"Safe change and rewind"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"create-mcp","component_type":"capability"},{"capability_id":"create-skill","component_type":"capability"},{"capability_id":"dex-add-mcp","component_type":"capability"},{"capability_id":"dex-whats-new","component_type":"capability"},{"capability_id":"integrate-mcp","component_type":"capability"},{"capability_id":"manage-capabilities","component_type":"capability"},{"capability_id":"skill-score","component_type":"capability"}],"family_id":"capability-discovery-and-adoption","jobs":["evolve-the-system-itself"],"member_capability_ids":["create-mcp","create-skill","dex-add-mcp","dex-whats-new","integrate-mcp","manage-capabilities","skill-score"],"outcome":"Useful methods can be discovered, reviewed, adopted and created through the safe lifecycle.","title":"Capability discovery and adoption"},{"aliases":[],"assessment":{"mode":"manual-only","reason":"A person must confirm that no private work leaves the machine before feedback is shared."},"components":[{"capability_id":"feedback","component_type":"capability"}],"family_id":"privacy-safe-feedback-loop","jobs":["evolve-the-system-itself"],"member_capability_ids":["feedback"],"outcome":"A problem can become a minimal report and a returned answer or fix without exporting private work.","title":"Privacy-safe feedback loop"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"career-coach","component_type":"capability"},{"capability_id":"career-setup","component_type":"capability"},{"capability_id":"dex-career-mcp","component_type":"capability"},{"capability_id":"dex-resume-mcp","component_type":"capability"},{"capability_id":"resume-builder","component_type":"capability"}],"family_id":"career-growth-evidence","jobs":["reflect-and-improve-continuously","track-career-growth"],"member_capability_ids":["career-coach","career-setup","dex-career-mcp","dex-resume-mcp","resume-builder"],"outcome":"Career and Resume tools turn consented evidence into development and application support without inventing claims.","title":"Career growth evidence"}],"jobs_taxonomy":[{"confirmed_gap_signals":["The Lens session finds a gap related to capture without friction."],"description":"Capture useful ideas, meeting context and incoming information before it disappears or becomes filing work.","job_id":"capture-without-friction","label":"Capture Without Friction"},{"confirmed_gap_signals":["The Lens session finds a gap related to start each day focused."],"description":"Turn current priorities, tasks and calendar pressure into a realistic focus for the day.","job_id":"start-each-day-focused","label":"Start Each Day Focused"},{"confirmed_gap_signals":["The Lens session finds a gap related to track people and relationships."],"description":"Keep the context, commitments and history needed to show up well for important people and organizations.","job_id":"track-people-and-relationships","label":"Track People & Relationships"},{"confirmed_gap_signals":["The Lens session finds a gap related to manage tasks reliably."],"description":"Keep tasks, promises and delegated work from scattering or quietly going unmet.","job_id":"manage-tasks-reliably","label":"Manage Tasks Reliably"},{"confirmed_gap_signals":["The Lens session finds a gap related to reflect and improve continuously."],"description":"Turn reflection, decisions and observed friction into durable learning and better ways of working.","job_id":"reflect-and-improve-continuously","label":"Reflect & Improve Continuously"},{"confirmed_gap_signals":["The Lens session finds a gap related to keep projects on track."],"description":"Maintain enough project truth, decisions and next actions to keep important work moving.","job_id":"keep-projects-on-track","label":"Keep Projects On Track"},{"confirmed_gap_signals":["The Lens session finds a gap related to track career growth."],"description":"Use consented evidence and reflection to support truthful career development and application material.","job_id":"track-career-growth","label":"Track Career Growth"},{"confirmed_gap_signals":["The Lens session finds a gap related to evolve the system itself."],"description":"Inspect, extend, update and recover the system without sacrificing human control or portability.","job_id":"evolve-the-system-itself","label":"Evolve the System Itself"}],"portable_brief":{"audience":"the person's own AI system","format":"markdown","safety_boundary":"Brief only: Lens presents adaptation guidance and never applies Dex changes automatically."}},"metadata":{"catalog_version":7,"contract_version":"dex-lens-catalogue-v2","core_release":"v0.0.0-preview","expires_at":"2026-09-24T12:00:00Z","key_id":"dex-core-lens-1","produced_at":"2026-08-25T12:00:00Z","producer":"Dex Core enriched preview (version-independent example)"},"signature":"UNSIGNED-PREVIEW-NOT-FOR-PUBLICATION"} +{"catalogue":{"capabilities":[{"availability":"active","capability_class":"active-skill","capability_id":"apple-mail-setup","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/apple-mail-setup/SKILL.md","summary":"The shipped Apple Mail Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["capture-without-friction"],"portable_brief":{"goal":"Set up and verify Apple Mail search on macOS, including the search index that silently returns nothing when it was never built.","method_outline":["Inspect the current local state and the person's request.","Run the Apple Mail Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.96.3","summary":"Set up and verify Apple Mail search on macOS, including the search index that silently returns nothing when it was never built. Use when the user says 'connect Apple Mail', 'set up mail search', 'Dex can't find my emails', 'mail search returns nothing'. Not for Gmail or Google Workspace; use `google-workspace-setup`.","title":"Apple Mail Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Set up and verify Apple Mail search on macOS, including the search index that silently returns nothing when it was never built."},{"availability":"active","capability_class":"active-skill","capability_id":"atlassian-setup","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/atlassian-setup/SKILL.md","summary":"The shipped Atlassian Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Connect Jira and Confluence for project tracking and knowledge search.","method_outline":["Inspect the current local state and the person's request.","Run the Atlassian Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Connect Jira and Confluence for project tracking and knowledge search. Use when the user says 'connect Jira', 'hook up Confluence', 'my tickets/board'. Not for a personal task app like Todoist/Things/Trello; use `todoist-setup`/`things-setup`/`trello-setup`.","title":"Atlassian Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Jira and Confluence for project tracking and knowledge search."},{"availability":"active","capability_class":"active-skill","capability_id":"backup-now","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","honest-health-observability","ownership-portability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["local-file-access","off-machine-destination"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"verified","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_backup_vault.py","summary":"Real behaviour coverage of a single run: a successful run stores the set and records it, a failure records the actual error rather than a generic one, and a run that fails part-way leaves no half-written copy behind to be mistaken for a good one."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/backup-now/SKILL.md","summary":"The shipped skill defines the on-demand run, the rule against inferring success from the command finishing, and the quiet note when the last successful copy is old."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Take a verified copy on demand before a risky change, and report the recorded result rather than the command's exit.","method_outline":["Run the same copying path the schedule uses; do not build a second one.","Read the run record afterwards and report what it says.","On failure, repeat the recorded reason exactly rather than softening it.","Mention quietly when the previous successful copy is old."],"rollback_advice":"Delete the copy that was just made; on-demand runs add a copy and never change the live material.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["A failed run is never reported as a copy that exists.","The reported size and destination come from the record, not the intent.","A run with no configured destination fails clearly instead of guessing one."]},"prerequisites":["Backups already configured; without a destination the run fails with a plain message rather than improvising one.","A minute or so, and room at the destination."],"release_provenance":"core-release","since_release":"1.95.1","summary":"Run a vault backup right now and report the verified result. Use when the user says 'back up now', 'take a backup before I do this', or is about to make a big change. Not for scheduling or changing where backups go (`backup-setup`); not for getting files back (`backup-restore`).","title":"Backup Now","trade_offs":["An on-demand copy covers one moment and is not a substitute for a schedule.","Success is read from the run record rather than from the command exiting, so a partial copy is reported as a failure."],"value":"Takes a copy right now, before a bulk edit or a migration, and reports what actually landed rather than treating a finished command as a success."},{"availability":"active","capability_class":"active-skill","capability_id":"backup-restore","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","ownership-portability","honest-health-observability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["local-file-access","off-machine-destination"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"verified","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_backup_vault.py","summary":"Real behaviour coverage of all three modes: verification passes on an intact copy and detects a damaged one, the test mode unpacks only into a temporary folder, a real restore refuses the live location and any folder that is not empty, and a damaged newest copy points at the newest intact one instead."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"doc: docs/backup-restore.md","summary":"The shipped recovery guide covers what a full rebuild needs beyond the copies, including the credentials and schedules deliberately left out of them."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/backup-restore/SKILL.md","summary":"The shipped skill defines the three modes, the routine test restore, and the rule to report exactly what the tool printed rather than a reassuring summary."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Prove a backup restores, and perform a real restore without ever writing over the live material.","method_outline":["Check the copy's fingerprints and history before trusting it.","Offer a routine test that unpacks into a throwaway folder and then deletes it.","For a real restore, require a new or empty destination and refuse the live one.","State plainly what is not in the copy and must be re-established by hand."],"rollback_advice":"Delete the folder the restore was written into; because a restore never targets the live location, removing that folder returns the system to its prior state.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["A deliberately damaged copy is detected rather than restored.","The live material is provably untouched after a restore.","A failed verification is reported as failure, with the next intact copy named."]},"prerequisites":["At least one completed copy to check.","A new or empty folder to restore into when a real recovery is wanted."],"release_provenance":"core-release","since_release":"1.95.1","summary":"Verify a vault backup, prove it restores, or restore it to a folder of the user's choosing. Use when the user says 'restore my backup', 'test my backups', 'are my backups any good', or after data loss. Never overwrites the live vault. Not for taking a backup (`backup-now`); not for scheduling (`backup-setup`).","title":"Backup Restore","trade_offs":["A restore never overwrites the live material, so moving it back into place stays a deliberate human step.","Where a copy is damaged it says so and points at the next intact one rather than pretending the newest is usable."],"value":"Proves the copies actually come back — fingerprints checked, the whole thing unpacked into a scratch folder — and, when a real recovery is needed, puts it somewhere new instead of over the live work."},{"availability":"active","capability_class":"active-skill","capability_id":"backup-setup","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","ownership-portability","honest-health-observability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["local-file-access","off-machine-destination","scheduler"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"verified","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_backup_vault.py","summary":"Real behaviour coverage of the copying engine and its scheduler: the ladder of older copies keeps what it claims and never deletes the newest one, a real sign-in token never reaches the archive, an ordinary note that merely looks secret is still kept, and on a system without the supported scheduler nothing is installed and the equivalent instruction is printed instead."},{"level":"verified","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_doctor.py","summary":"The health check's backup probe is covered directly: a recent, successful run that quietly stored less than a full copy is reported as broken rather than passing as fine."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"doc: docs/backup-restore.md","summary":"The shipped recovery guide states what a full rebuild needs beyond the copies themselves, including the things deliberately excluded from them."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/backup-setup/SKILL.md","summary":"The shipped skill defines the destination choice, the retention ladder, the scheduling step, and the rule that setup is not reported as done until a real run has succeeded."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Set up scheduled, verified copies of the person's whole working record, kept somewhere other than the machine that made them.","method_outline":["Choose a destination off the machine, and never write credentials into it.","Exclude keys, tokens and caches from the copy on purpose, and say what was excluded.","Keep a ladder of recent and older copies, and never delete the newest one.","Prove it by running one for real before calling the setup finished.","Add a health check that treats a stale copy as a problem, not a warning."],"rollback_advice":"Remove the scheduled job and the backup settings; existing copies stay where they are and the person's live material is never touched by the setup.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["A real credential file is provably absent from the copy.","The newest copy survives even a retention rule that would delete everything.","A run that failed is reported as failed, with the recorded reason."]},"prerequisites":["A synced folder or a cloud storage account for the copies to go to.","Automatic scheduling is wired up for macOS; on other systems the person is given the exact line to schedule it themselves, and nothing is installed behind their back."],"release_provenance":"core-release","since_release":"1.95.1","summary":"Set up automatic vault backups to a synced folder or a cloud provider, with verified archives and tiered retention. Use when the user says 'back up my vault', 'set up backups', 'where are my backups going', or asks about losing their notes. Not for restoring or testing a restore (`backup-restore`); not for a one-off backup right now (`backup-now`).","title":"Backup Setup","trade_offs":["Keys and sign-in tokens are deliberately left out of the copies, so rebuilding on a new machine means entering those again.","A backup that has never been test-restored is still only a hope, which is why proving the restore is a separate step."],"value":"Puts the person's whole working record on a schedule that copies it somewhere else, keeps a ladder of older copies, and says so loudly when it quietly stops working."},{"availability":"active","capability_class":"active-skill","capability_id":"calendar-setup","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/calendar-setup/SKILL.md","summary":"The shipped Calendar Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["start-each-day-focused"],"portable_brief":{"goal":"Grant Python calendar access for ~30x faster calendar queries.","method_outline":["Inspect the current local state and the person's request.","Run the Calendar Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Grant Python calendar access for ~30x faster calendar queries. Use when the user says 'connect my calendar', 'calendar is slow', 'set up calendar access'. Not for connecting Google Workspace as a whole; use `google-workspace-setup`.","title":"Calendar Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Grant Python calendar access for ~30x faster calendar queries."},{"availability":"active","capability_class":"active-skill","capability_id":"change-job","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","scoped-agency-human-control","durable-memory-provenance"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory","durable-goals-or-tasks","task-or-note-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_instruction_honesty.py","summary":"Pins the transition's load-bearing promises: the settings after-check is relayed word for word, a failed check stops every later pass, nothing is deleted, each project is its own question, and connections are listed for review, never removed. The tests read the shipped instructions."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_transition_capsule.py","summary":"Covers the snapshot-and-verify lane the transition relies on: the pre-change capture, the after-check that names lost or unexpected changes, and the exact restore of the two settings files."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/change-job/SKILL.md","summary":"The shipped skill defines the five passes, the rule that every pass is previewed, confirmed and skippable, and the closing ledger naming what changed and how to undo each step."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Guide a job or role transition where every pass is previewed, confirmed, skippable, and undoable, and the settings that were not re-answered provably carry forward.","method_outline":["Lay out the five passes in plain words and get a yes before starting.","Re-run setup with carry-forward; relay the after-check and stop everything if it fails.","Re-sort people from their recorded emails, plan shown first, never guessing.","Archive the old role's planning whole and walk projects one at a time.","Re-point open tasks at the new pillars and hand grooming to the backlog skill."],"rollback_advice":"The settings snapshot restores the two configuration files exactly as captured; archived pages move back from the dated role-transition folder; the people re-sort reverses by running it against the old domain.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["A failed settings check stops the transition before any later pass runs.","Nothing is deleted; every exit is archive, park, or leave alone.","The closing ledger names each pass done or skipped and how to undo it."]},"prerequisites":["A vault that completed first-time setup.","The new role's work email domain, so people can be re-sorted."],"release_provenance":"core-release","since_release":"1.97.7","summary":"Guided job or role transition: re-run the setup questions with every unanswered setting carried forward and checked afterwards, re-sort people for the new work email domain, archive the old role's goals, priorities and projects (never deleted), re-point open tasks at the new pillars, and close with a ledger of what changed and how to undo each step. Use when the user says 'I changed jobs', 'I'm changing jobs', 'new role', 'new job', 'went full-time', or 'I'm now [role] at [company]'. Not for a preference change within the same job; use `reset`. Not for first-time setup; use `setup`.","title":"Change Job","trade_offs":["The setup questions are asked again in full, even when only a few answers changed.","People with no recorded email are left where they are rather than guessed, so a few pages may still need moving by hand."],"value":"Moves a whole Dex from one job to the next without losing anything: setup answers carried forward and checked against a snapshot, people re-sorted for the new work email, the old role's planning archived rather than deleted, and open tasks re-pointed at the new pillars."},{"availability":"active","capability_class":"active-skill","capability_id":"commitments","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","meeting-source","task-or-note-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_commitments_skill.py","summary":"Dedicated tests pin the load-bearing promises: it reuses the existing scanner rather than building a second one, never creates a task without confirmation, says so plainly when the scan is unavailable instead of inventing a list, and reads back what it created before reporting. The tests read the shipped instructions, not a live scan."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/commitments/SKILL.md","summary":"The shipped skill defines the present-then-confirm flow, the split between promises made and asks received, and the refusal to pad an empty result."}],"impact_tier":"core","jobs":["manage-tasks-reliably"],"portable_brief":{"goal":"Create a review that surfaces open promises and asks from existing records and tracks only the ones the person confirms.","method_outline":["Read the existing commitment sources rather than building a second store.","Drop anything already tracked, and group the rest by who owes whom.","Put genuinely ambiguous items in an unclear group instead of guessing direction.","Offer each item for confirmation, then read back exactly what was created."],"rollback_advice":"Delete the tasks the review created; the meetings and notes it read from are never modified, so the source record is unaffected.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["An empty result is reported as empty, not padded with vague follow-ups.","No item becomes tracked work without an explicit yes.","Every item reported as captured has a real identifier behind it."]},"prerequisites":["Meeting notes or people records the scan can read.","A task list the confirmed commitments can become."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Reconcile the promises you made and the asks you received across meetings and notes into a clear owner/due/source list, then — only with your confirmation — turn the real ones into tracked tasks. Use when the user says 'what did I promise', 'what am I on the hook for', 'anything I owe people', 'loose ends', or after a run of meetings. Also use proactively during daily-plan/daily-review when uncaptured commitments surface. Not for tracking work you handed off to others; use `delegate-check`. Not for recording a decision you made; use `decision-log`.","title":"Commitments","trade_offs":["Which direction a promise runs is inferred from wording, so genuinely unclear items are shown as unclear rather than guessed.","Nothing becomes tracked without item-by-item confirmation, which costs the person a little attention each time."],"value":"Pulls the small promises — “I’ll send that over”, “can you review this” — out of meetings and notes into one list of who owes what, and tracks only the ones the person confirms are real."},{"availability":"active","capability_class":"active-skill","capability_id":"create-mcp","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/create-mcp/SKILL.md","summary":"The shipped Create Mcp skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Build a brand-new MCP integration from scratch with a guided wizard.","method_outline":["Inspect the current local state and the person's request.","Run the Create Mcp workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Build a brand-new MCP integration from scratch with a guided wizard. Use when the user wants Dex to talk to a tool that has no existing server — 'build an integration for X', 'Dex can't connect to Y yet'. Not for installing an MCP that already exists; use `integrate-mcp`. Not for a prompt-only workflow with no external tool; use `create-skill`.","title":"Create Mcp","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Build a brand-new MCP integration from scratch with a guided wizard."},{"availability":"active","capability_class":"active-skill","capability_id":"create-skill","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/create-skill/SKILL.md","summary":"The shipped Create Skill skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Author a new Dex skill.","method_outline":["Inspect the current local state and the person's request.","Run the Create Skill workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Author a new Dex skill — a reusable `/command` — that actually fires and passes the quality bar. Runs a collision check, classifies the shape, writes a router-grade description, generates the real package (SKILL.md + evals), and grades it with `skill-score` before calling it done. Use when the user says 'make a skill', 'I want a /command for X', 'turn this into a skill'. A skill the user builds for themselves is saved under `.claude/skills-custom/` (protected from updates) and coached, never blocked; a first-party skill is held to the hard gate. Not for connecting an external tool; use `create-mcp`. Not for grading a skill that already exists; use `skill-score`.","title":"Create Skill","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Author a new Dex skill."},{"availability":"active","capability_class":"active-skill","capability_id":"daily-plan","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","readable-task-source"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_commitments_skill.py","summary":"The planning path is covered where commitments become bounded, reviewable tasks."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/daily-plan/SKILL.md","summary":"The shipped skill defines the daily planning workflow and its required source checks."}],"impact_tier":"core","jobs":["start-each-day-focused"],"portable_brief":{"goal":"Create a daily planning routine that combines meetings, tasks and commitments into one bounded plan.","method_outline":["Read current commitments and calendar shape.","Choose a short list that fits the available time.","Keep any task creation reviewable by the person."],"rollback_advice":"Disable or remove the planning command; the workflow should not require irreversible data changes.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The output names a realistic number of actions for today.","The person can reject or edit task changes before anything persists."]},"prerequisites":["A readable task list or commitment source.","Calendar access improves the plan but is not the only input."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Build today's plan from calendar, tasks, priorities and commitments, with smart scheduling suggestions. Use when the user says 'plan my day', 'what's on today', 'help me focus', or starts the morning. Also use proactively at the first session of the day. Not for reviewing a finished day; use `daily-review`.","title":"Daily Plan","trade_offs":["The plan is only as current as the sources it can inspect.","It drafts priorities; the person still chooses what to do."],"value":"Helps a person choose a small, realistic focus list before the day scatters across meetings, tasks and loose commitments."},{"availability":"active","capability_class":"active-skill","capability_id":"daily-review","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","readable-task-source","durable-memory-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_review_retirement.py","summary":"A dedicated test pins the end-of-day behaviour Dex ships: the review runs in the current conversation, and where a review already exists for today it checks that one rather than writing a competing second version. It reads the shipped instructions, not a live day."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_skill_delegated_gathering.py","summary":"Covers the paired gathering instructions this review depends on for a large collection of notes, so the heavy reading step cannot be silently orphaned by a later edit."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/daily-review/SKILL.md","summary":"The shipped skill defines the end-of-day workflow, the check against an existing review, and the confirmation rules before anything is written."}],"impact_tier":"high","jobs":["start-each-day-focused","reflect-and-improve-continuously"],"portable_brief":{"goal":"Create an end-of-day routine that compares intention with what actually happened and sets one starting point for tomorrow.","method_outline":["Read the day's plan, completed work and any meeting record the person approved.","Name what was finished, what slipped and what a meeting left owing.","Check whether a review already exists for today and correct it rather than duplicating it.","Agree one starting point for tomorrow with the person before writing anything."],"rollback_advice":"Stop running the routine and delete the generated review files; the underlying tasks, notes and meeting records are never rewritten by it, so they need no undo.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The review distinguishes finished work from work that merely moved.","A second run on the same day does not create a competing record.","Nothing is written to the person's own material without their confirmation."]},"prerequisites":["Today's plan, tasks or notes in a place the system can read.","A few minutes with the person; the review asks questions it cannot answer for them."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Close out the day: what got done vs planned, meeting follow-ups, learnings, and tomorrow's focus. Use when the user says 'review my day', 'wrap up', 'end of day', or it's evening. Also use proactively when the day's work is clearly done. Not for setting up the morning; use `daily-plan`.","title":"Daily Review","trade_offs":["A review can only see the parts of the day that were written down somewhere.","It proposes tomorrow's focus and any change to the record; the person confirms both."],"value":"Closes the day the morning plan opened: what actually got done against what was intended, what a meeting left behind, and what tomorrow starts with — so the loop finishes instead of drifting."},{"availability":"active","capability_class":"active-skill","capability_id":"decision-log","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability","context-orientation"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-memory-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_adoption_effective_behavior.py","summary":"Real behaviour coverage of how this capability is switched on and off again: the test adopts it through Dex's live change system, proves the change can be rewound exactly, and proves a rewind refuses rather than overwrite a file the person has since edited. That covers the switch-on path, not the recording conversation itself."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/decision-log/SKILL.md","summary":"The shipped skill defines what a decision record must contain, where it is filed, and the rule that earlier entries are never rewritten to make history look cleaner."}],"impact_tier":"high","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Create a decision record that captures the choice, the real alternatives, the reasoning and when to revisit it.","method_outline":["Search for an earlier decision on the same topic before recording a new one.","Capture the choice, what made it necessary, the options considered and why this one won.","Set a review date, or state plainly that no review is needed.","File it in the narrowest useful place and confirm where it went."],"rollback_advice":"Delete the appended decision entry; earlier entries are never modified, so removing the new one restores the previous state exactly.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The record contains no option or reason the person did not actually give.","An earlier decision it replaces is linked rather than overwritten.","Dates are absolute, so the record still reads correctly years later."]},"prerequisites":["A home for decisions that is separate from the meeting they came out of.","The person's own account of the options; the record never supplies reasoning they did not give."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Capture an important decision with its context, options, rationale, and review date, then find it again when it matters.","title":"Decision Log","trade_offs":["A decision record earns its keep only if it can be found again, which depends on where it is filed.","A superseded decision is added as a new entry rather than edited, so the history grows rather than tidies."],"value":"Keeps the reason behind a choice — the options, the rationale, the date to look at it again — so nobody has to reconstruct it from memory months later."},{"availability":"active","capability_class":"active-skill","capability_id":"delegate-check","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","task-or-note-store","relationship-history"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_adoption_effective_behavior.py","summary":"Real behaviour coverage of how this capability is switched on and off again: the test adopts it through Dex's live change system, proves the change can be rewound exactly, and proves a rewind refuses rather than overwrite a file the person has since edited. That covers the switch-on path, not the review conversation itself."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/delegate-check/SKILL.md","summary":"The shipped skill defines what counts as an open handoff, the order attention is spent in, and the rule that no message is sent and no record changed without approval."}],"impact_tier":"high","jobs":["manage-tasks-reliably"],"portable_brief":{"goal":"Create a delegation review that separates moving work from stuck work and proposes one proportionate follow-up.","method_outline":["Collect open handoffs from tasks and recent meeting notes, and merge duplicates.","For each, record what, who, when it was handed over, what is expected and when.","Order the review by what needs attention, keeping healthy items brief.","Draft one short nudge per stuck item and send nothing without approval."],"rollback_advice":"Stop running the review and discard its drafts; it changes a record only after the person confirms, so nothing needs to be undone on their behalf.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Silence is reported as unclear status, never as progress or failure.","Conflicting records are shown as a conflict rather than resolved silently.","No message leaves and no status changes without an explicit yes."]},"prerequisites":["Tasks or meeting notes that record who owns what.","The person's approval before any nudge is sent or any status is changed."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Review open delegations — what you handed off, to whom, its status, and the next useful nudge. Use when the user says 'what did I delegate', 'who owes me', 'check my handoffs', 'follow up with someone'. Not for prepping a meeting; use meeting-prep.","title":"Delegate Check","trade_offs":["Where two records disagree about status, it shows the disagreement instead of quietly picking one.","It will not chase a handoff whose agreed date has not arrived, so a genuinely early risk can still be missed."],"value":"Shows what was handed to other people, what is moving, what is stuck and the one short nudge worth sending — and reports silence as unknown rather than as progress."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-add-mcp","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-add-mcp/SKILL.md","summary":"The shipped Dex Add Mcp skill defines the workflow Lens is cataloguing."}],"impact_tier":"medium","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Add a known MCP server to config using Dex-safe user scope.","method_outline":["Inspect the current local state and the person's request.","Run the Dex Add Mcp workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Add a known MCP server to config using Dex-safe user scope. Use when the user has server details in hand and says 'add this MCP', 'register this server'. Not for discovering/installing from a marketplace; use `integrate-mcp`. Not for building one; use `create-mcp`.","title":"Dex Add Mcp","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Add a known MCP server to config using Dex-safe user scope."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-backlog","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-backlog/SKILL.md","summary":"The shipped Dex Backlog skill defines the workflow Lens is cataloguing."}],"impact_tier":"medium","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Show the AI-ranked backlog of Dex system-improvement ideas.","method_outline":["Inspect the current local state and the person's request.","Run the Dex Backlog workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Show the AI-ranked backlog of Dex system-improvement ideas. Use when the user says 'show my Dex ideas', 'what's in the backlog', 'what should we build next'. Not for workshopping one idea into a plan; use `dex-improve`. Not for discovering existing features; use `dex-level-up`.","title":"Dex Backlog","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Show the AI-ranked backlog of Dex system-improvement ideas."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-doctor","changed_in":[],"compatibility":{"foundation_capabilities":["honest-health-observability","safe-change-recovery","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["local-diagnostics","feature-status-vocabulary"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"verified","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_doctor.py","summary":"Doctor behavior is covered by the main health-check test suite."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-doctor/SKILL.md","summary":"The shipped skill defines the checkup flow and safe repair boundary."}],"impact_tier":"core","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Create a local health check that distinguishes working, off, broken and unknown states without over-claiming.","method_outline":["Probe the same paths the real features use.","Report unknown when evidence is incomplete.","Keep any repair action behind a separate approval path."],"rollback_advice":"Disable repair actions first; the diagnostic report can remain read-only.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["A sabotaged probe does not become working.","Unknown and off states are visible to the person.","No secret value appears in output."]},"prerequisites":["A host can run local checks against its own configuration.","Repair paths must be separately gated from diagnosis."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Whole-system checkup: verifies every Dex feature honestly (working/off/broken/couldn't-check), self-heals what's provably safe, guides the rest. Use when the user says 'is Dex healthy', 'something's broken', 'check my setup', 'run diagnostics'. Not for discovering unused *features*; use `dex-level-up`. Not for applying an update; use `dex-update`.","title":"Dex Doctor","trade_offs":["A check can report unknown when evidence is missing.","Automatic repair must remain limited to provably safe fixes."],"value":"Gives the person an honest system check: what works, what is off, what is broken and what should not be guessed."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-improve","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-improve/SKILL.md","summary":"The shipped Dex Improve skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Workshop one improvement idea into an implementation plan.","method_outline":["Inspect the current local state and the person's request.","Run the Dex Improve workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Workshop one improvement idea into an implementation plan. Use when the user says 'let's flesh out idea-X', 'turn this into a plan', 'improve Dex's Y'. Not for ranking the whole backlog; use `dex-backlog`. Not for a PRD for the user's own product; use `product-brief`.","title":"Dex Improve","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Workshop one improvement idea into an implementation plan."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-level-up","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-level-up/SKILL.md","summary":"The shipped Dex Level Up skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Surface Dex features the user isn't using yet, based on their usage patterns.","method_outline":["Inspect the current local state and the person's request.","Run the Dex Level Up workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Surface Dex features the user isn't using yet, based on their usage patterns. Use when the user says 'what am I missing', 'show me new features', 'level up my Dex'. Not for diagnosing what's broken; use `dex-doctor`. Not for what changed in a release; use `dex-whats-new`.","title":"Dex Level Up","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Surface Dex features the user isn't using yet, based on their usage patterns."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-obsidian-setup","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-obsidian-setup/SKILL.md","summary":"The shipped Dex Obsidian Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"medium","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Turn on Obsidian mode and migrate the vault to wiki links.","method_outline":["Inspect the current local state and the person's request.","Run the Dex Obsidian Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Turn on Obsidian mode and migrate the vault to wiki links. Use when the user says 'I use Obsidian', 'enable wiki links', 'make this work in Obsidian'. Not for connecting an external tool/API; use `create-mcp`/`integrate-mcp`.","title":"Dex Obsidian Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Turn on Obsidian mode and migrate the vault to wiki links."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-orient","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-orient/SKILL.md","summary":"The shipped Dex Orient skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Orient a Dex Core contributor in release truth, local changes and the canonical architecture maps.","method_outline":["Inspect the current local state and the person's request.","Run the Dex Orient workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.69.0","summary":"Orient in the Dex Core codebase: prints the released version, what's merged-but-not-released, and where the architecture map + inventory live. Use at the start of any dex-core development or investigation, or whenever you're unsure what's shipped vs built-locally vs prototype.","title":"Dex Orient","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Orient in the Dex Core codebase: prints the released version, what's merged-but-not-released, and where the architecture map + inventory live. Use at the start of any dex-core development or investigation, or whenever you're unsure what's shipped vs built-locally vs prototype."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-rollback","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-rollback/SKILL.md","summary":"The shipped Dex Rollback skill defines the workflow Lens is cataloguing."}],"impact_tier":"core","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Rewind one receipt-backed Dex adoption through the frozen lifecycle service.","method_outline":["Inspect the current local state and the person's request.","Run the Dex Rollback workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Rewind one receipt-backed Dex adoption through the frozen lifecycle service. Use when the user says 'undo the update', 'go back', 'that broke something after updating'. Not for applying an update; use `dex-update`.","title":"Dex Rollback","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Rewind one receipt-backed Dex adoption through the frozen lifecycle service."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-update","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-update/SKILL.md","summary":"The shipped Dex Update skill defines the workflow Lens is cataloguing."}],"impact_tier":"core","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Preview and safely adopt a Dex update through the receipt-backed lifecycle (look → back up → apply → verify → rewindable).","method_outline":["Inspect the current local state and the person's request.","Run the Dex Update workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Preview and safely adopt a Dex update through the receipt-backed lifecycle (look → back up → apply → verify → rewindable). Use when the user says 'update Dex', 'install the new version', or a release notice appeared. Not for undoing an update; use `dex-rollback`. Not just seeing what changed; use `dex-whats-new`.","title":"Dex Update","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Preview and safely adopt a Dex update through the receipt-backed lifecycle (look → back up → apply → verify → rewindable)."},{"availability":"active","capability_class":"active-skill","capability_id":"dex-whats-new","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/dex-whats-new/SKILL.md","summary":"The shipped Dex Whats New skill defines the workflow Lens is cataloguing."}],"impact_tier":"medium","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Show recent system improvements.","method_outline":["Inspect the current local state and the person's request.","Run the Dex Whats New workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Show recent system improvements — captured learnings plus new Claude capabilities. Use when the user says 'what's new', 'any updates to how Dex works'. Not for previewing and applying a version update; use `dex-update`. Not for unused existing features; use `dex-level-up`.","title":"Dex Whats New","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Show recent system improvements."},{"availability":"active","capability_class":"active-skill","capability_id":"diff-adopt","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/diff-adopt/SKILL.md","summary":"The shipped Diff Adopt skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Adopt one shared DexDiff methodology.","method_outline":["Inspect the current local state and the person's request.","Run the Diff Adopt workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.49.0","summary":"Adopt one shared DexDiff methodology — reads a workflow description, adapts it to your role and vault, and walks you through setup. Use when the user says 'adopt this workflow', 'set me up like this doc'. Not for a full published profile by handle; use `diff-adopt-profile`.","title":"Diff Adopt","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Adopt one shared DexDiff methodology."},{"availability":"active","capability_class":"active-skill","capability_id":"diff-adopt-profile","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/diff-adopt-profile/SKILL.md","summary":"The shipped Diff Adopt Profile skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Adopt a full published Heydex profile by handle ('set me up like @davekilleen').","method_outline":["Inspect the current local state and the person's request.","Run the Diff Adopt Profile workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.49.0","summary":"Adopt a full published Heydex profile by handle ('set me up like @davekilleen'). Use when the user says 'set me up like ', or names a handle. Not for a single workflow doc; use `diff-adopt`. Not for creating your own profile; use `diff-profile`.","title":"Diff Adopt Profile","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Adopt a full published Heydex profile by handle ('set me up like @davekilleen')."},{"availability":"active","capability_class":"active-skill","capability_id":"diff-generate","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/diff-generate/SKILL.md","summary":"The shipped Diff Generate skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Package one workflow.","method_outline":["Inspect the current local state and the person's request.","Run the Diff Generate workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.49.0","summary":"Package one workflow — how you use Dex for a specific job — into a shareable DexDiff methodology doc. Use when the user says 'share how I do X', 'package this workflow'. Not for packaging your *entire* system; use `diff-profile`. Not for adopting someone else's; use `diff-adopt`.","title":"Diff Generate","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Package one workflow."},{"availability":"active","capability_class":"active-skill","capability_id":"diff-list","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/diff-list/SKILL.md","summary":"The shipped Diff List skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Show all adopted DexDiff workflows.","method_outline":["Inspect the current local state and the person's request.","Run the Diff List workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.49.0","summary":"Show all adopted DexDiff workflows — what's installed, when it was adopted, and what it includes","title":"Diff List","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Show all adopted DexDiff workflows."},{"availability":"active","capability_class":"active-skill","capability_id":"diff-profile","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/diff-profile/SKILL.md","summary":"The shipped Diff Profile skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Package your entire Dex system into a shareable DexDiff profile so others can replicate how you work.","method_outline":["Inspect the current local state and the person's request.","Run the Diff Profile workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.49.0","summary":"Package your entire Dex system into a shareable DexDiff profile so others can replicate how you work. Use when the user says 'share my whole setup', 'publish my profile'. Not for a single workflow; use `diff-generate`. Not for adopting a whole profile; use `diff-adopt-profile`.","title":"Diff Profile","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Package your entire Dex system into a shareable DexDiff profile so others can replicate how you work."},{"availability":"active","capability_class":"active-skill","capability_id":"diff-remove","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/diff-remove/SKILL.md","summary":"The shipped Diff Remove skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Remove a previously adopted DexDiff workflow.","method_outline":["Inspect the current local state and the person's request.","Run the Diff Remove workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.49.0","summary":"Remove a previously adopted DexDiff workflow — deletes its generated skills and config, leaves your data untouched. Use when the user says 'remove that workflow', 'undo the adoption'. Not for listing what's installed; use `diff-list`.","title":"Diff Remove","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Remove a previously adopted DexDiff workflow."},{"availability":"active","capability_class":"active-skill","capability_id":"enable-semantic-search","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","privacy-minimal-disclosure","ownership-portability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","local-search-index","durable-memory-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/enable-semantic-search/SKILL.md","summary":"The shipped skill defines the pre-flight checks, the guided local install, the collections it discovers from the person's own material, and the later health check on those collections. There is no test of the workflow's own judgement calls; the shipped skill file is the definition of the behaviour, which is why this entry claims support rather than proof."}],"impact_tier":"high","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Add meaning-based search over the person's own notes, running locally, without sending their material anywhere.","method_outline":["Check what is already installed before proposing anything.","Explain in plain terms what is being installed and roughly what it costs in space.","Discover the natural groupings in the person's own material rather than imposing one.","Fall back cleanly to exact-word search wherever the index is unavailable."],"rollback_advice":"Remove the local search index and its tool; every workflow that used it falls back to exact-word search, and the notes themselves are never modified.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Notes never leave the person's machine as part of the setup.","A search by meaning finds a note that shares no words with the query.","Every routine that uses it still works when the index is absent."]},"prerequisites":["A one-off local setup with room on the machine for the search index.","Enough accumulated notes that exact-word searching is already missing things."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Turn on local AI-powered semantic (meaning-based) search over the vault, with smart collection discovery. Use when the user says 'enable semantic search', 'search by meaning', 'set up QMD', or search keeps missing obvious matches. Not for scraping the web; use `scrape`.","title":"Enable Semantic Search","trade_offs":["The guided setup names macOS package steps; other systems need their own equivalents.","Meaning-based results are broader than exact matches, so an occasional loose result is the price of finding the right one."],"value":"Makes the person's own notes searchable by meaning rather than exact wording, on their own machine — so looking for “customer churn” still finds the note that said “people keep leaving”."},{"availability":"active","capability_class":"active-skill","capability_id":"feedback","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/feedback/SKILL.md","summary":"The shipped Feedback skill defines the workflow Lens is cataloguing."}],"impact_tier":"core","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Report a Dex bug to the Dex team with zero homework.","method_outline":["Inspect the current local state and the person's request.","Run the Feedback workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.82.0","summary":"Report a Dex bug to the Dex team with zero homework — Dex investigates locally, builds a privacy-safe report, shows it to you (or auto-sends if you've chosen that), and tracks the ticket until it's fixed. Use when the user says \"report this\", \"send this to the Dex team\", \"file feedback\", \"/feedback\", asks \"what happened to my bug report\", or accepts Doctor's offer to report a Dex bug. Also use when the user describes something in Dex misbehaving in their own words, without asking for a report at all — \"the meeting sync is doing something weird\", \"this keeps breaking\", \"X stopped working\", \"that's not what I asked for\" — investigate first, then offer. Not for capturing ideas about your own vault or workflow; use the improvements backlog for those. Not for trouble in the user's own notes, calendar or projects, which is never a Dex defect.","title":"Feedback","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Report a Dex bug to the Dex team with zero homework."},{"availability":"active","capability_class":"active-skill","capability_id":"getting-started","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/getting-started/SKILL.md","summary":"The shipped Getting Started skill defines the workflow Lens is cataloguing."}],"impact_tier":"core","jobs":["start-each-day-focused"],"portable_brief":{"goal":"Give a new Dex user a practical post-onboarding tour that adapts to the data already available.","method_outline":["Inspect the current local state and the person's request.","Run the Getting Started workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Interactive post-onboarding tour that adapts to whatever data exists (calendar, Granola, or none). Use right after onboarding, or when the user says 'show me around', 'how do I start'. Also use proactively when the vault is < 7 days old. Not for the initial setup itself; use `setup`.","title":"Getting Started","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Interactive post-onboarding tour that adapts to whatever data exists (calendar, Granola, or none). Use right after onboarding, or when the user says 'show me around', 'how do I start'. Also use proactively when the vault is < 7 days old. Not for the initial setup itself; use `setup`."},{"availability":"active","capability_class":"active-skill","capability_id":"goal-backlog","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-goals-or-tasks","task-or-note-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_instruction_honesty.py","summary":"Pins the load-bearing promises: no task is deleted or moved silently, deletions are previewed line by line and approved per task, parking preserves content, and the offer to structure freeform goals is made once. The tests read the shipped instructions."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_work_server_task_goal_readers.py","summary":"Covers the grouped backlog reader the skill drives: grouping by goal, the pick-up-first ordering, staleness counts, and the handling of provisional goals recovered from freeform text."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/goal-backlog/SKILL.md","summary":"The shipped skill defines the one-goal-at-a-time pass, the four honest exits for stale work, and the rule that nothing leaves the backlog without a yes."}],"impact_tier":"high","jobs":["manage-tasks-reliably"],"portable_brief":{"goal":"Create a grooming pass that shows open work under each quarter goal and records the user's own decisions about what stays, what goes, and what gets picked up first.","method_outline":["Load the grouped backlog and present the largest and stalest groups first.","Confirm or clear each doubtful goal link before anything else.","Offer four exits for stale work - done, parked, deleted with per-task approval, or kept.","Record the pick-up-first order weekly planning will pull from."],"rollback_advice":"Move a parked task's lines back from the Someday file to the tasks file to revive it; ask to clear a pick-up-first order to undo it. Deletions are the one permanent exit, which is why each requires its own yes.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Nothing is deleted or moved without the exact lines shown and a yes for that task.","The offer to structure freeform goals is made once, never repeated after a no.","An empty backlog is reported as empty, not padded with invented work."]},"prerequisites":["Quarterly goals in the structured page shape, so tasks can link to them.","An open task backlog in the standard tasks file."],"release_provenance":"core-release","since_release":"1.97.7","summary":"Groom the open task pool goal by goal: see everything under each quarter goal, confirm doubtful goal links, retire what has gone stale, and mark what gets picked up first when that goal earns week-time. Use when the user says 'groom my backlog', 'what's under this goal', 'my tasks are a swamp', 'clean up my tasks', or when open tasks have piled up untouched. Not for routing new inbox items; use `triage`. Not for setting the week's priorities; use `week-plan`.","title":"Goal Backlog","trade_offs":["Staleness is measured from when a task was created, not from real activity, so a task advanced elsewhere can look idle.","Every retirement is confirmed item by item, which costs attention on a large backlog."],"value":"Turns a flat, overgrown task list back into a groomed pool: open work shown goal by goal, doubtful links confirmed, stale items retired only with approval, and a picked-up-first order that weekly planning actually uses."},{"availability":"active","capability_class":"active-skill","capability_id":"google-workspace-setup","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/google-workspace-setup/SKILL.md","summary":"The shipped Google Workspace Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["capture-without-friction"],"portable_brief":{"goal":"Connect Google Workspace (Gmail, Calendar, Docs) for email-aware planning and meeting prep.","method_outline":["Inspect the current local state and the person's request.","Run the Google Workspace Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Connect Google Workspace (Gmail, Calendar, Docs) for email-aware planning and meeting prep. Use when the user says 'connect Gmail/Google', 'hook up my work email'. Not for local macOS calendar speed only; use `calendar-setup`. Not for Microsoft; use `ms-teams-setup`.","title":"Google Workspace Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Google Workspace (Gmail, Calendar, Docs) for email-aware planning and meeting prep."},{"availability":"active","capability_class":"active-skill","capability_id":"granola-setup","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/granola-setup/SKILL.md","summary":"The shipped Granola Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["capture-without-friction"],"portable_brief":{"goal":"Connect Granola via its official API for automatic meeting sync and transcripts.","method_outline":["Inspect the current local state and the person's request.","Run the Granola Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Connect Granola via its official API for automatic meeting sync and transcripts. Use when the user says 'connect Granola', 'my meetings aren't syncing', 'set up meeting notes'. Not for Zoom recordings; use `zoom-setup`. Not for processing meetings already synced; use `process-meetings`.","title":"Granola Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Granola via its official API for automatic meeting sync and transcripts."},{"availability":"active","capability_class":"active-skill","capability_id":"identity-snapshot","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability","honest-health-observability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-memory-store","durable-goals-or-tasks"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/identity-snapshot/SKILL.md","summary":"The shipped skill defines the sources it reads, the structure of the profile it writes, and its rule to report a neglected area honestly rather than flatter the person. There is no test of the workflow's own judgement calls; the shipped skill file is the definition of the behaviour, which is why this entry claims support rather than proof."}],"impact_tier":"high","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Create an observed profile of how a person works, generated from their own records rather than from self-description.","method_outline":["Read the accumulated goals, priorities, tasks and captured learnings.","Describe patterns using actual data points, not general statements.","Say plainly where an area is neglected or where pace dropped.","Date every generation so change over time is visible."],"rollback_advice":"Delete the generated profile; it is written from other records and never modifies them, so removing it loses nothing else.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Nothing in the profile was asked of the person directly.","A missing source is marked as missing rather than smoothed over.","Each claim can be traced to a specific record."]},"prerequisites":["Enough accumulated history for a pattern to exist; a new system has nothing to read.","A place for the profile to live and be replaced as it changes."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Generate a living profile of the user's working patterns, decision tendencies and quality preferences from their Dex data. Use when the user says 'what are my patterns', 'how do I work', or during `week-review`. Also use proactively when the model (older than 7 days) is stale. Not for planning a week; use `week-plan`.","title":"Identity Snapshot","trade_offs":["It sees only what was captured, so habits that never got written down are invisible to it.","Generated too early it describes noise; it becomes useful after months of material."],"value":"Writes a dated profile of how the person actually works, built from their own accumulated records rather than from what they say about themselves — so drift over months becomes visible."},{"availability":"active","capability_class":"active-skill","capability_id":"industry-truths","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability","context-orientation"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-memory-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/industry-truths/SKILL.md","summary":"The shipped skill defines the three time horizons, the interview that draws the beliefs out, and the later passes that review them and compare them against what actually happened. There is no test of the workflow's own judgement calls; the shipped skill file is the definition of the behaviour, which is why this entry claims support rather than proof."}],"impact_tier":"high","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Create a record of time-horizoned beliefs about a market so strategic choices can be checked against stated assumptions.","method_outline":["Draw out beliefs by conversation rather than by form-filling.","Separate them into what is true now, what is emerging, and what is a bet.","Record who or what the person watches for signals of change.","Schedule a later pass that compares the beliefs against what actually happened."],"rollback_advice":"Delete the assumptions file; it is a standalone record, and strategy notes that referenced it simply lose the link.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Each belief is specific enough to be proved wrong.","The horizon each belief sits in is explicit.","There is a stated point at which the beliefs get reviewed."]},"prerequisites":["A domain the person genuinely follows, and roughly fifteen minutes of conversation.","A willingness to be wrong in writing; the value arrives when the beliefs are checked later."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Define time-horizoned assumptions about your industry (today / 6mo / 12mo) that ground strategic thinking. Use when the user is making roadmap, positioning or investment calls, or says 'what am I assuming about the market'. Also use proactively before a big strategic recommendation. Not for capturing a single decision; use `decision-log`.","title":"Industry Truths","trade_offs":["Assumptions written once and never revisited age badly, and can mislead more than having none.","It records beliefs, not evidence; the sources behind them remain the person's responsibility."],"value":"Makes the beliefs a strategy rests on explicit — what is true today, in six months, in a year — so later decisions can be checked against them instead of quietly assuming them."},{"availability":"active","capability_class":"active-skill","capability_id":"initiative-kickoff","changed_in":[],"compatibility":{"foundation_capabilities":["scoped-agency-human-control","durable-memory-provenance","context-orientation"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-goals-or-tasks","project-records"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_initiative_kickoff_skill.py","summary":"Dedicated tests pin the load-bearing promises: success signals must be checkable, no connection to a goal is manufactured where none fits, nothing is created without confirmation, and the person's setting for creating new people records is respected. The tests read the shipped instructions, not a live kickoff."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/initiative-kickoff/SKILL.md","summary":"The shipped skill defines the framing questions, the honest ladder to goals, and the read-back of what was created before anything is called kicked off."}],"impact_tier":"high","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Create a kickoff routine that turns a decision to start something into an outcome, checkable success signals, an owner and first steps.","method_outline":["Get the outcome, the reason it is worth starting now, and what is out of scope.","Name two to four signals somebody could actually check later.","Name the accountable owner and the people involved.","Connect it to a real existing goal, or record it honestly as a standalone bet.","Draft the first few steps and create only the ones confirmed."],"rollback_advice":"Delete the initiative record and the first steps it created; nothing else in the person's goals or projects is altered by the kickoff.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every success signal could be verified by someone else months later.","No connection to a goal exists that the goals themselves do not support.","What is reported as created matches what actually exists."]},"prerequisites":["A decision already taken; this is where a decision becomes work, not where it gets made.","Somewhere to keep the initiative, and existing goals to connect it to if any exist."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Turn a decision to start something new — a hire, a partnership, a go-to-market push, an internal bet — into a real initiative: the outcome and why now, what success looks like, who's involved, the first concrete steps, and a project page that ladders to your pillars and goals. Use when the user says 'let's kick off X', 'I'm starting a new initiative', 'set up a project for this', or 'we've decided to do Y'. Also use proactively when the user commits to a new effort mid-conversation. Not for spec'ing a product feature or writing a PRD; use `product-brief`. Not for checking the status of projects already underway; use `project-health`.","title":"Initiative Kickoff","trade_offs":["Where an initiative does not connect to a real goal it is recorded as a standalone bet rather than tied to an invented one.","Success signals have to be checkable later, which takes more thought up front than a general aim."],"value":"Turns “we’ve decided to do this” into something that can actually start: an outcome, signs of success somebody could check later, a named owner and the first few steps."},{"availability":"active","capability_class":"active-skill","capability_id":"integrate-mcp","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/integrate-mcp/SKILL.md","summary":"The shipped Integrate Mcp skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Install and wire up an existing MCP server from Smithery.ai or a GitHub repo.","method_outline":["Inspect the current local state and the person's request.","Run the Integrate Mcp workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Install and wire up an existing MCP server from Smithery.ai or a GitHub repo. Use when the user names a tool that already has a server — 'add the Notion MCP', 'install this Smithery server'. Not for building a new integration from nothing; use `create-mcp`. Not for adding one already-known server safely; use `dex-add-mcp`.","title":"Integrate Mcp","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Install and wire up an existing MCP server from Smithery.ai or a GitHub repo."},{"availability":"active","capability_class":"active-skill","capability_id":"journal","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/journal/SKILL.md","summary":"The shipped Journal skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Toggle journaling or start a morning/evening/weekly journal entry.","method_outline":["Inspect the current local state and the person's request.","Run the Journal workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Toggle journaling or start a morning/evening/weekly journal entry. Use when the user says 'journal', 'morning pages', 'evening reflection'. Also use proactively when a journaling-enabled user starts/ends the day. Not for a structured end-of-day work review; use `daily-review`.","title":"Journal","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Toggle journaling or start a morning/evening/weekly journal entry."},{"availability":"active","capability_class":"active-skill","capability_id":"manage-capabilities","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/manage-capabilities/SKILL.md","summary":"The shipped Manage Capabilities skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Turn optional Dex rooms/features on or off without deleting any content.","method_outline":["Inspect the current local state and the person's request.","Run the Manage Capabilities workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.63.0","summary":"Turn optional Dex rooms/features on or off without deleting any content. Use when the user says 'turn off X', 'enable the career room', 'hide a feature I don't use'. Not for diagnosing breakage; use `dex-doctor`. Not for a full role restructure; use `reset`.","title":"Manage Capabilities","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Turn optional Dex rooms/features on or off without deleting any content."},{"availability":"active","capability_class":"active-skill","capability_id":"meeting-closeout","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","scoped-agency-human-control","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","meeting-source","task-or-note-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_meeting_closeout_skill.py","summary":"Dedicated tests pin the load-bearing promises: this is one meeting rather than a bulk catch-up, owners are named or honestly marked unknown, the person's setting for creating new people records is respected, no task is created without confirmation, and a meeting it cannot find is asked for rather than reconstructed. The tests read the shipped instructions, not a live meeting."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/meeting-closeout/SKILL.md","summary":"The shipped skill defines the closeout, the hard boundary on where meeting material may be read from, and the read-back before anything is reported as captured."}],"impact_tier":"high","jobs":["capture-without-friction"],"portable_brief":{"goal":"Create a single-meeting closeout that captures decisions, owners, personal promises and one next step while they are still fresh.","method_outline":["Work only from notes the person supplied or from their own configured store.","Extract decisions, action items with a named owner, personal promises and one next step.","Mark an owner the notes do not name as unknown instead of assigning one.","Offer each follow-up for confirmation, then read back what was actually saved."],"rollback_advice":"Delete the generated closeout note and any follow-ups it created; the original meeting notes are appended to or left alone, never rewritten.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["No decision, owner or promise appears that the notes do not support.","A meeting with no available notes produces a request, never a recap.","What is reported as saved matches what is actually on disk."]},"prerequisites":["Notes from the meeting — pasted, dictated, or already saved wherever the person keeps them.","Somewhere to write the follow-ups the person approves."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Close out the meeting you just had while it's fresh — lock the decisions, the action items and who owns each, what you personally committed to, and the single next step — then capture it and, only with your OK, turn the actions into tracked tasks. Use when the user says 'wrap up this meeting', 'close out my 3pm', 'here are my notes from the call', or right after a meeting ends. Also use proactively when the user pastes raw notes from a meeting that just happened. Not for bulk-processing many already-synced meetings; use `process-meetings`. Not for prepping a meeting that hasn't happened yet; use `meeting-prep`.","title":"Meeting Closeout","trade_offs":["It will not go looking in outside services for a meeting it cannot find; it asks for the notes instead.","Owners the notes do not name are recorded as unknown rather than guessed, which leaves real gaps visible."],"value":"Locks one meeting's decisions, owners and personal promises while it is still fresh, and refuses to invent an owner or a recap for a meeting it cannot actually see."},{"availability":"active","capability_class":"active-skill","capability_id":"meeting-prep","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","privacy-minimal-disclosure","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","relationship-history","meeting-source"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_meeting_prep_calendar_journey.py","summary":"Statically checks the calendar-first instruction contract and journey order across the inline skill and delegated research prompt, including required attendee filters, feature-status guidance, and the structured person-page handoff; it does not simulate Calendar MCP runtime behavior."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_instruction_honesty.py","summary":"A dedicated test pins that this capability reports a source that is switched off or broken in Dex's honest wording, rather than letting a gap in the gathering pass as a finished brief."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_skill_delegated_gathering.py","summary":"Covers the paired gathering instructions the prep depends on when the history is large, so the reading step cannot be orphaned by a later edit."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/meeting-prep/SKILL.md","summary":"The shipped skill defines what is gathered, how the brief is shaped for the person's seniority and preferences, and the requirement to spot-check claims before presenting them."}],"impact_tier":"high","jobs":["capture-without-friction"],"portable_brief":{"goal":"Create a pre-meeting brief that gathers attendee history and open threads from approved sources and states what it could not find.","method_outline":["Identify the meeting and its attendees from the calendar or the person's own words.","Read only approved history: past notes, people records, related project material.","Confirm a sample of the files the brief cites actually exist before repeating them.","Present context, open threads and suggested talking points, and name the gaps."],"rollback_advice":"Stop running the routine; the brief is produced for the conversation and changes nothing in the person's own records, so there is nothing to unwind.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every claim in the brief traces to a file that exists.","Missing history is stated as missing rather than filled in plausibly.","No source outside the approved reading scope is opened."]},"prerequisites":["A calendar entry, or simply the meeting named out loud.","Some history worth gathering: earlier notes, people records or related project material."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Prepare for a specific upcoming meeting by gathering attendee context, history and related topics. Use when the user says 'prep me for my meeting with X', 'what do I need for the 2pm', or before a calendar event. Also use proactively when a meeting is imminent. Not for writing up a meeting that already happened; use `process-meetings`.","title":"Meeting Prep","trade_offs":["A brief is only as good as the history already captured; a genuinely first meeting has little to gather.","Anything the brief claims should be checked against the real file before it is repeated in the room."],"value":"Walks into the meeting already holding the attendees, the history and the open threads, instead of spending the last five minutes searching for them."},{"availability":"active","capability_class":"active-skill","capability_id":"ms-teams-setup","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/ms-teams-setup/SKILL.md","summary":"The shipped Ms Teams Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["track-people-and-relationships"],"portable_brief":{"goal":"Connect Microsoft Teams for cross-channel context awareness.","method_outline":["Inspect the current local state and the person's request.","Run the Ms Teams Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Connect Microsoft Teams for cross-channel context awareness. Use when the user says 'connect Teams', 'hook up Microsoft'. Not for Google email/calendar; use `google-workspace-setup`.","title":"Ms Teams Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Microsoft Teams for cross-channel context awareness."},{"availability":"active","capability_class":"active-skill","capability_id":"pipedrive-setup","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/pipedrive-setup/SKILL.md","summary":"The shipped Pipedrive Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["track-people-and-relationships"],"portable_brief":{"goal":"Connect Pipedrive CRM for a live pipeline view and confirm-gated deal updates.","method_outline":["Inspect the current local state and the person's request.","Run the Pipedrive Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.95.1","summary":"Connect Pipedrive CRM for a live pipeline view and confirm-gated deal updates. Use when the user says 'connect Pipedrive', 'link my CRM', 'sync my pipeline with Pipedrive'. Not for pipeline analysis without a CRM; use `pipeline-health`. Not for reconciling an already-connected CRM; use `pipeline-sync`.","title":"Pipedrive Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Pipedrive CRM for a live pipeline view and confirm-gated deal updates."},{"availability":"active","capability_class":"active-skill","capability_id":"pipeline-sync","changed_in":[],"compatibility":{"foundation_capabilities":["scoped-agency-human-control","honest-health-observability","safe-change-recovery","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","pipedrive-connection","pipeline-sync-companion"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions cover partial reads, prerequisites, confirmation and recovery limits."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_pipedrive_server.py","summary":"Pipedrive adapter tests support key read and write safety behavior, not complete synchronization."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/pipeline-sync/SKILL.md","summary":"The active release skill defines the pipeline reconciliation workflow."}],"impact_tier":"high","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Reconciles Pipedrive deal facts with local strategy notes through explicit previews and read-back checks.","method_outline":["Discover complete deal and note inputs.","Map differences without treating partial reads as complete.","Preview, confirm and read back each approved reconciliation."],"rollback_advice":"Stop the reconciliation and keep both systems unchanged; use the last preview and read-back receipt to recover any confirmed partial update.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Incomplete reads remain visibly incomplete.","A retry does not assume idempotency without proof."]},"prerequisites":["A configured Pipedrive connection the host can read.","The pipeline-sync companion instructions and explicit authority for any proposed write."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Live view of your Pipedrive pipeline reconciled against your local pipeline tracker; flags drift, maps focus deals, and pushes confirmed updates to the CRM. Use when the user says 'sync my pipeline', 'show me my pipeline', 'reconcile the CRM'. Not for connecting Pipedrive in the first place; use `pipedrive-setup`.","title":"Pipeline Sync","trade_offs":["It requires both the Pipedrive connection and its companion instructions; write behavior remains human-confirmed and only supported, not behaviorally verified.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Reconciles Pipedrive deal facts with local strategy notes through explicit previews and read-back checks."},{"availability":"active","capability_class":"active-skill","capability_id":"process-meetings","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","meeting-source","task-or-note-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_process_meetings_soft_commitment_wiring.py","summary":"Meeting processing is covered where soft commitments are detected and routed."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/process-meetings/SKILL.md","summary":"The shipped skill defines the meeting processing workflow."}],"impact_tier":"core","jobs":["capture-without-friction","track-people-and-relationships"],"portable_brief":{"goal":"Create a meeting processing routine that extracts decisions, commitments and relationship context from approved meeting material.","method_outline":["Read only the approved meeting source.","Identify decisions, action items and people references.","Offer reviewable tasks or note updates."],"rollback_advice":"Disable the meeting processor and remove generated follow-up drafts; keep original meeting notes untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["No unrelated meeting content is read.","Every proposed follow-up cites the meeting source.","The person can edit before task creation."]},"prerequisites":["Meeting notes or transcripts in a readable local source.","A place to write reviewable follow-up tasks."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Turn synced meetings into updated person pages, extracted tasks and organized notes. Use when the user says 'process my meetings', 'catch up my notes', or after Granola/Otter syncs. Also use proactively when unprocessed meetings exist. Not for prepping an upcoming meeting; use `meeting-prep`.","title":"Process Meetings","trade_offs":["Transcript quality controls output quality.","Private meeting material must stay within the host's declared read scope."],"value":"Turns meeting material into people context and follow-up tasks, reducing the chance that decisions or promises disappear after the call."},{"availability":"active","capability_class":"active-skill","capability_id":"product-brief","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","project-records"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/product-brief/SKILL.md","summary":"The shipped skill defines the guided extraction, the questions asked in conversation rather than as a form, and the structure of the brief it produces. There is no test of the workflow's own judgement calls; the shipped skill file is the definition of the behaviour, which is why this entry claims support rather than proof."}],"impact_tier":"high","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Create a guided questioning routine that turns a rough product idea into a written brief a team could execute.","method_outline":["Start from whatever the person has, however rough, without judging it.","Ask two or three questions at a time, conversationally, and wait for answers.","Fill the gaps that matter — who it is for, what problem, what success looks like.","Produce the written brief and keep it where the work will happen."],"rollback_advice":"Delete the generated brief; the questioning changes nothing else, so no other record needs restoring.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Nothing in the brief was supplied by the system rather than the person.","Open questions are listed as open, not resolved by assumption.","The brief is specific enough for someone else to act on."]},"prerequisites":["An idea worth the time; the questioning is guided but not instant.","Somewhere to keep the finished brief next to the work it belongs to."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Extract a product idea through guided questions and generate a PRD. Use when the user says 'write a PRD', 'spec this feature', 'turn this idea into a brief'. Not for a non-product initiative like hiring or partnerships (use `initiative-kickoff` once shipped); not for checking existing projects' status (use `project-health`).","title":"Product Brief","trade_offs":["The brief is only as sharp as the answers given; it will not invent a market, a user or a measure.","It is shaped around product work, so a hire, a partnership or an operational bet is served better elsewhere."],"value":"Draws a half-formed product idea out through questions and leaves a written brief a team could actually build from, instead of an idea that only made sense in one head."},{"availability":"active","capability_class":"active-skill","capability_id":"project-health","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","project-records"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/project-health/SKILL.md","summary":"The shipped skill defines the four checks it makes per project — activity, active tasks, blockers and next-step clarity — and the traffic-light thresholds behind them. There is no test of the workflow's own judgement calls; the shipped skill file is the definition of the behaviour, which is why this entry claims support rather than proof."}],"impact_tier":"high","jobs":["start-each-day-focused"],"portable_brief":{"goal":"Create a fast scan across active projects that reports what is stale, blocked or missing a clear next step.","method_outline":["List the active projects and read when each last changed.","Check whether each has current tasks, a recorded blocker and a clear next action.","Report one line per project with the reason it was flagged.","Keep the output short enough to read in one pass."],"rollback_advice":"Stop running the scan; it reads project material and writes a report, so removing the report leaves the projects exactly as they were.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every flag names the specific reason it was raised.","Thresholds for stale and blocked are stated, not implied.","A healthy project takes one line, not a paragraph."]},"prerequisites":["Project notes the scan can read.","Some record of recent activity, so going quiet means something."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Scan active projects for status, blockers and next actions. Use when the user says 'how are my projects', 'what's stuck', 'project status'. Also use proactively when projects have gone quiet. Not for writing a spec for a new product idea; use `product-brief`.","title":"Project Health","trade_offs":["Quietness is judged from when project files last changed, which misreads work happening somewhere else.","It is deliberately small: it flags what to look at, it does not diagnose why."],"value":"Answers “what’s stuck?” across every active project in one pass: how long since anything moved, what is blocked, and whether the next step is actually clear."},{"availability":"active","capability_class":"active-skill","capability_id":"prompt-improver","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/prompt-improver/SKILL.md","summary":"The shipped Prompt Improver skill defines the workflow Lens is cataloguing."}],"impact_tier":"medium","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Rewrite a vague prompt into a rich, structured one, with automatic fallback.","method_outline":["Inspect the current local state and the person's request.","Run the Prompt Improver workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Rewrite a vague prompt into a rich, structured one, with automatic fallback. Use when the user says 'improve this prompt', 'make this prompt better', or hands over a thin instruction. Not for creating a reusable skill; use `create-skill`.","title":"Prompt Improver","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Rewrite a vague prompt into a rich, structured one, with automatic fallback."},{"availability":"active","capability_class":"active-skill","capability_id":"relationship-radar","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["relationship-history","skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_relationship_radar_skill.py","summary":"Relationship radar skill behavior is covered in the skill test."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/relationship-radar/SKILL.md","summary":"The shipped skill defines the cold-relationship workflow."}],"impact_tier":"high","jobs":["track-people-and-relationships"],"portable_brief":{"goal":"Create a relationship review that identifies important contacts with stale recent engagement.","method_outline":["Read approved relationship or meeting evidence.","Rank by importance and recency.","Suggest reviewable next actions rather than sending messages."],"rollback_advice":"Remove the radar command or delete its generated suggestions; do not alter source relationship history.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The output names why each person surfaced.","No message is sent automatically.","The person can dismiss or defer a suggestion."]},"prerequisites":["A relationship or meeting history source.","A rule for what counts as important enough to surface."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Spot the relationships going cold — people you were in regular contact with and haven't touched in a while, and important contacts who are slipping — ranked by how stale each has become, so you can reconnect before it costs you. Use when the user says 'who should I reach out to', 'who am I losing touch with', 'who's going cold', 'who needs attention', or during a weekly review. Also use proactively when someone important hasn't come up in a long time. Not for prepping a specific upcoming meeting; use `meeting-prep`. Not for specific promises you owe people; use `commitments`.","title":"Relationship Radar","trade_offs":["Recency signals can miss context the system cannot see.","The person still decides whether to reach out."],"value":"Shows important relationships that are going quiet so the person can reconnect before silence becomes a problem."},{"availability":"active","capability_class":"active-skill","capability_id":"reset","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/reset/SKILL.md","summary":"The shipped Reset skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Restructure an existing Dex vault for a new role or changed preferences, without losing data.","method_outline":["Inspect the current local state and the person's request.","Run the Reset workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Re-run the setup questions over an existing Dex vault when preferences or setup answers changed, without losing data. Use when the user says 'restructure my Dex', 'redo my setup', 'my pillars are wrong now'. Not for a job or role change; use `change-job` — it runs this same reset plus the people, archive and task passes. Not for first-time setup; use `setup`. Not for just toggling one feature; use `manage-capabilities`.","title":"Reset","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Restructure an existing Dex vault for a new role or changed preferences, without losing data."},{"availability":"active","capability_class":"active-skill","capability_id":"review","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/review/SKILL.md","summary":"The shipped Review skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Keeps the old review command working by handing it directly to the current daily review workflow.","method_outline":["Inspect the current local state and the person's request.","Run the Review workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Deprecation alias for `daily-review`. The end-of-day review was renamed; `/review` now redirects to `daily-review` and will be removed after one release. Use when the user types `/review` out of habit — hand straight off to `daily-review`, which owns end-of-day review and learning capture. Not for running the review here; use `daily-review`.","title":"Review","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Keeps the old review command working by handing it directly to the current daily review workflow."},{"availability":"active","capability_class":"active-skill","capability_id":"save-insight","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability","context-orientation"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["durable-memory-store","skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_learning_capture_command_name.py","summary":"Learning capture command naming is pinned by tests."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/save-insight/SKILL.md","summary":"The shipped skill defines the reusable-learning capture flow."}],"impact_tier":"high","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Create a lightweight learning capture routine for reusable lessons from completed work.","method_outline":["Ask what changed future behavior.","Store only the reusable rule and source context.","Prefer small scoped memories over broad summaries."],"rollback_advice":"Delete or archive the saved learning entry; keep original project records separate.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The saved item has a clear reuse condition.","It does not contain secrets or raw private material.","Future work can cite where it came from."]},"prerequisites":["A durable memory or notes store.","A review habit for deciding what is worth keeping."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Capture a reusable learning from completed work so future similar work is easier. Use when the user says 'save this learning', 'capture this insight', or finishes something tricky. Also use proactively after non-routine work. Not for recording a *decision* and its rationale; use `decision-log`.","title":"Save Insight","trade_offs":["Low-quality memories can clutter future context.","The person or system needs a rule for when to save learning."],"value":"Turns a learning from completed work into durable context future agents can reuse instead of rediscovering it."},{"availability":"active","capability_class":"active-skill","capability_id":"scrape","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/scrape/SKILL.md","summary":"The shipped Scrape skill defines the workflow Lens is cataloguing."}],"impact_tier":"niche","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Scrape web pages via Scrapling.","method_outline":["Inspect the current local state and the person's request.","Run the Scrape workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Scrape web pages via Scrapling — stealth fetching, anti-bot bypass, CSS selectors, no API key. Use when the user says 'scrape', 'pull data from this URL', 'extract from this site'. Not for meaning-based search of the user's own vault; use `enable-semantic-search`.","title":"Scrape","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Scrape web pages via Scrapling."},{"availability":"active","capability_class":"active-skill","capability_id":"setup","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/setup/SKILL.md","summary":"The shipped Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"core","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Run first-time Dex onboarding: build the vault structure, capture the user profile and configure MCPs.","method_outline":["Inspect the current local state and the person's request.","Run the Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Run first-time Dex onboarding: build the vault structure, capture the user profile and configure MCPs. Use when `System/.onboarding-complete` is absent or the user says 'set up Dex', 'start onboarding'. Not for the post-onboarding tour; use `getting-started`. Not for a mid-life role change; use `reset`.","title":"Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Run first-time Dex onboarding: build the vault structure, capture the user profile and configure MCPs."},{"availability":"active","capability_class":"active-skill","capability_id":"skill-score","changed_in":[],"compatibility":{"foundation_capabilities":["safe-change-recovery","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/skill-score/SKILL.md","summary":"The shipped Skill Score skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["evolve-the-system-itself"],"portable_brief":{"goal":"Grade a Dex skill against the shape-aware quality rubric and report a ship/revise/no verdict with the exact fixes.","method_outline":["Inspect the current local state and the person's request.","Run the Skill Score workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available."],"release_provenance":"core-release","since_release":"1.69.0","summary":"Grade a Dex skill against the shape-aware quality rubric and report a ship/revise/no verdict with the exact fixes. Use when you finish writing or editing a skill, when create-skill hands off a new package, before shipping a first-party skill, or when the user asks \"is this skill any good / will it fire / score my skill\". Also use proactively right after any SKILL.md is created or its description changes. Not for authoring a new skill from scratch (use create-skill) or fixing broken YAML frontmatter alone (create-skill's validator does that); skill-score judges architecture and routing, not just format.","title":"Skill Score","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","The workflow can guide and verify a bounded action, but cannot guarantee the underlying system is healthy."],"value":"Grade a Dex skill against the shape-aware quality rubric and report a ship/revise/no verdict with the exact fixes."},{"availability":"active","capability_class":"active-skill","capability_id":"things-setup","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/things-setup/SKILL.md","summary":"The shipped Things Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["manage-tasks-reliably"],"portable_brief":{"goal":"Connect Things 3 (macOS only) so Dex reads and updates your Things tasks.","method_outline":["Inspect the current local state and the person's request.","Run the Things Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Connect Things 3 (macOS only) so Dex reads and updates your Things tasks. Use when the user says 'I use Things', 'sync my Things inbox', or pastes a `things://` link. Not for Todoist (`todoist-setup`) or Trello (`trello-setup`).","title":"Things Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Things 3 (macOS only) so Dex reads and updates your Things tasks."},{"availability":"active","capability_class":"active-skill","capability_id":"todoist-setup","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/todoist-setup/SKILL.md","summary":"The shipped Todoist Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["manage-tasks-reliably"],"portable_brief":{"goal":"Connect Todoist so Dex reads and updates your Todoist tasks two ways.","method_outline":["Inspect the current local state and the person's request.","Run the Todoist Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Connect Todoist so Dex reads and updates your Todoist tasks two ways. Use when the user says 'I use Todoist', 'sync Todoist', or pastes a todoist.com link. Not for Things 3 (`things-setup`) or Trello (`trello-setup`); not for Jira tickets (`atlassian-setup`).","title":"Todoist Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Todoist so Dex reads and updates your Todoist tasks two ways."},{"availability":"active","capability_class":"active-skill","capability_id":"trello-setup","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/trello-setup/SKILL.md","summary":"The shipped Trello Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["manage-tasks-reliably"],"portable_brief":{"goal":"Connect Trello so Dex reads your boards and manages cards.","method_outline":["Inspect the current local state and the person's request.","Run the Trello Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Connect Trello so Dex reads your boards and manages cards. Use when the user says 'I use Trello', 'my Trello board', or pastes a trello.com link. Not for Todoist (`todoist-setup`) or Things (`things-setup`).","title":"Trello Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Trello so Dex reads your boards and manages cards."},{"availability":"active","capability_class":"active-skill","capability_id":"triage","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-goals-or-tasks","task-or-note-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/triage/SKILL.md","summary":"The shipped skill defines the routing workflow, the index it builds of existing projects and people, and the way current priorities raise confidence in a destination. There is no test of the workflow's own judgement calls; the shipped skill file is the definition of the behaviour, which is why this entry claims support rather than proof."}],"impact_tier":"core","jobs":["manage-tasks-reliably"],"portable_brief":{"goal":"Create a routing pass that clears loose captures into the right home using the person's current priorities.","method_outline":["Read current priorities and goals before touching the pile.","Build an index of the existing projects, people and areas that could receive an item.","Route each item to its best home, and leave anything genuinely unclear untouched.","Keep the decision per item fast; this is a clearing pass, not an analysis."],"rollback_advice":"Move the routed files back to the capture folder; the routing only relocates and links items, so their content is unchanged.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Items matching current priorities surface first.","Nothing is filed to a destination the person cannot recognise.","Unclear items are left in place rather than moved somewhere plausible."]},"prerequisites":["A capture folder or set of notes where loose items actually accumulate.","Current priorities or goals, so routing follows what matters now rather than in general."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Route orphaned inbox files and pull scattered `- [ ]` tasks into the right project/person/goal using current priorities. Use when the user says 'clean up my inbox', 'triage', 'sort out these notes'. Also use proactively when `00-Inbox/` is piling up. Not for updating notes from meetings; use `process-meetings`.","title":"Triage","trade_offs":["Routing is a fast suggestion rather than a considered judgement, and is meant to be reviewed.","An item with no clear home is left where it is rather than filed somewhere merely plausible."],"value":"Clears the pile-up: loose files and stray unticked boxes get routed to the project, person or goal they belong to, weighted by what the person said matters this week."},{"availability":"active","capability_class":"active-skill","capability_id":"week-plan","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-goals-or-tasks"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_work_server_weekly_priority_creation.py","summary":"Weekly priority creation is covered through the Work MCP path."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/week-plan/SKILL.md","summary":"The shipped skill defines the weekly planning routine."}],"impact_tier":"high","jobs":["start-each-day-focused"],"portable_brief":{"goal":"Create a weekly planning routine that maps goals and commitments to a bounded set of priorities.","method_outline":["Read goals, open tasks and calendar pressure.","Select a short priority set for the week.","Expose uncertainty instead of forcing a fake complete plan."],"rollback_advice":"Remove the weekly planning command or its scheduled reminder; preserve the underlying tasks and goals.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The plan names priorities, not a generic task dump.","Capacity limits are visible in the output."]},"prerequisites":["Some durable goal or task record the host can read.","A cadence for reviewing the plan."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Set the week's priorities against goals, calendar shape and task effort. Use when the user says 'plan my week', 'what should I focus on this week', or on their first working day. Also use proactively at the first session of a new week. Not for reviewing the week just past; use `week-review`.","title":"Week Plan","trade_offs":["A weekly plan can become stale mid-week unless the person revisits it.","It depends on honest capacity data."],"value":"Turns goals, capacity and open work into a weekly focus plan, so repeated work starts from priorities rather than a blank chat."},{"availability":"active","capability_class":"active-skill","capability_id":"week-review","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-goals-or-tasks"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_instruction_honesty.py","summary":"A dedicated test pins that the weekly review reads the person's own configured working week and lands on their last working day, rather than assuming everyone finishes on a Friday."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_skill_delegated_gathering.py","summary":"Covers the paired gathering instructions the weekly review depends on, so the bulk reading step cannot be orphaned by a later edit."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/week-review/SKILL.md","summary":"The shipped skill defines the weekly review, its insistence on concrete measures over percentages, and the goal and pattern discussion that stays with the person."}],"impact_tier":"high","jobs":["start-each-day-focused","reflect-and-improve-continuously"],"portable_brief":{"goal":"Create a weekly review that reports concrete finished work and honest gaps instead of a synthetic progress score.","method_outline":["Gather the week's priorities, completed work and meeting record first.","Report what finished, what did not, and what changed — in countable terms.","Surface repeating patterns as questions for the person rather than verdicts.","Confirm next week's priorities with the person before recording them."],"rollback_advice":"Stop running the routine and delete the generated weekly summaries; priorities and goals live in their own records and are left as they were.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["No percentage or score appears that the underlying data cannot support.","Unfinished work is named plainly rather than folded into an average.","The review runs on the person's own last working day, not a fixed one."]},"prerequisites":["A record of the week's priorities or goals to review against.","The person's own working week, so the review lands on their last working day rather than an assumed Friday."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Review the week with concrete accomplishments (not fake percentages), pattern detection and goal tracking. Use when the user says 'how was my week', 'week review', or it's their last working day. Also use proactively when a week's priorities are largely resolved. Not for planning the coming week; use `week-plan`.","title":"Week Review","trade_offs":["An honest review depends on the week having been written down as it happened.","The patterns it names are prompts for the person's judgement, not conclusions about them."],"value":"Reviews the week in concrete finished work and the patterns behind it, and deliberately refuses to invent a completion percentage that would make a bad week look measured."},{"availability":"active","capability_class":"active-skill","capability_id":"weekly-reflection","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","scoped-agency-human-control","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","durable-memory-store"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_adoption_effective_behavior.py","summary":"Real behaviour coverage of how this capability is switched on and off again: the test adopts it through Dex's live change system, proves the change can be rewound exactly, and proves a rewind refuses rather than overwrite a file the person has since edited. That covers the switch-on path, not the reflection conversation itself."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/weekly-reflection/SKILL.md","summary":"The shipped skill defines the three questions, the one-at-a-time pacing, and the rule against turning a feeling into a task or forcing a positive lesson."}],"impact_tier":"high","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Create a short weekly reflection on how work felt, kept separate from any measure of what was produced.","method_outline":["Ask what gave energy, one question at a time, and reflect the answer back.","Ask what drained energy, and offer any pattern as a possibility rather than a diagnosis.","Ask for one small, observable change the person controls.","Offer to keep the answers; accept no as an answer."],"rollback_advice":"Delete the saved reflection entry; entries are appended, so earlier writing is untouched and removal restores the previous state.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The week is not graded, scored or turned into a lesson.","The chosen change is small enough to actually happen.","Nothing is saved that the person did not agree to save."]},"prerequisites":["A few quiet minutes; this is the one thing that cannot be done on the person's behalf.","Somewhere private to keep the answers, or the choice not to keep them at all."],"release_provenance":"core-release","since_release":"1.80.0","summary":"A short guided reflection on what energized you, what drained you, and one change for next week. Use when the user wants to reflect on how work *felt*, not what got done — 'reflect on my week', 'what's draining me'. Not for progress-and-goals tracking; use `week-review`.","title":"Weekly Reflection","trade_offs":["It deliberately does not measure or score the week, which some people will want instead.","Reflection compounds only if the answers are kept and read again later."],"value":"Three questions about how the week felt — what gave energy, what took it, one thing to change — kept deliberately separate from the record of what got done."},{"availability":"active","capability_class":"active-skill","capability_id":"wispr-setup","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/wispr-setup/SKILL.md","summary":"The shipped Wispr Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["capture-without-friction"],"portable_brief":{"goal":"Connect Wispr Flow so meeting captures arrive in the vault on their own.","method_outline":["Inspect the current local state and the person's request.","Run the Wispr Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.97.0","summary":"Connect Wispr Flow so meeting captures arrive in your vault on their own. Use when the user says 'connect Wispr', 'set up Wispr Flow', 'my Wispr meetings aren't in Dex'. Not for Granola; use `granola-setup`. Not for processing meetings already in the vault; use `process-meetings`.","title":"Wispr Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Wispr Flow so meeting captures arrive in the vault on their own."},{"availability":"active","capability_class":"active-skill","capability_id":"xray","changed_in":[],"compatibility":{"foundation_capabilities":["honest-health-observability","context-orientation","compounding-correctability"],"host_adapters":["claude-code","cowork"],"host_requirements":["skills-directory","local-diagnostics"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/xray/SKILL.md","summary":"The shipped skill defines the default mode that explains the current conversation, the deeper modes on how the system is built and how to extend it, and the show-the-work-then-explain-why structure. There is no test of the workflow's own judgement calls; the shipped skill file is the definition of the behaviour, which is why this entry claims support rather than proof."}],"impact_tier":"high","jobs":["reflect-and-improve-continuously"],"portable_brief":{"goal":"Explain the mechanics of what the system just did, using the current conversation as the teaching material.","method_outline":["Identify what was read, written, and which tools ran in this conversation.","Explain why each step was necessary, in the person's own terms.","Connect each concrete step to the underlying idea it demonstrates.","End with what the person could change or extend themselves."],"rollback_advice":"Stop offering the explanation; it only reads and describes the conversation, so nothing in the person's system needs to be undone.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every step described actually happened in this conversation.","Nothing is presented as a health verdict about the system.","The explanation would make sense to someone who did not build it."]},"prerequisites":["A conversation that has actually done something worth explaining.","A host that can report the steps it took during that conversation."],"release_provenance":"core-release","since_release":"1.80.0","summary":"Explain what just happened under the hood — the context, MCP tools, and hooks behind Dex's last response — as AI education. Use when the user says 'how did you do that', 'what just happened', 'explain the mechanics'. Not for a system health check; use `dex-doctor`.","title":"Xray","trade_offs":["It explains what happened; it is not a health check and will not say whether anything is broken.","The explanation is only as accurate as what the host exposes about its own run."],"value":"Explains what the system just did and why — which files it read, which tools ran, what was loaded before the conversation even started — so the person learns their own setup instead of trusting it blindly."},{"availability":"active","capability_class":"active-skill","capability_id":"zoom-setup","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/zoom-setup/SKILL.md","summary":"The shipped Zoom Setup skill defines the workflow Lens is cataloguing."}],"impact_tier":"high","jobs":["capture-without-friction"],"portable_brief":{"goal":"Connect Zoom for meeting recordings, scheduling and transcript context.","method_outline":["Inspect the current local state and the person's request.","Run the Zoom Setup workflow within its documented safety boundary.","Verify the intended result and report anything still needing attention."],"rollback_advice":"Disable or remove the skill if it is not useful; reverse any external configuration through the same provider-controlled setup path.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The workflow reports what it found or changed.","The person keeps control over any consequential action."]},"prerequisites":["An installed Dex release with its skills directory available.","Access to the relevant local app or external service, authorized by the person."],"release_provenance":"core-release","since_release":"1.20.1","summary":"Connect the official Zoom for Claude connector for meeting recordings, transcripts, AI summaries, cloud-recording lists and Zoom Chat/Canvas search. Use when the user says 'connect Zoom', 'pull my Zoom recordings', 'search my Zoom meetings'. Not for Granola-sourced notes; use `granola-setup`. Not for Teams; use `ms-teams-setup`.","title":"Zoom Setup","trade_offs":["Results depend on the current local data and permissions the skill can inspect.","External connections remain subject to the provider's availability and authorization."],"value":"Connect Zoom for meeting recordings, scheduling and transcript context."},{"availability":"dormant","capability_class":"active-skill","capability_id":"account-plan","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/sales/account-plan/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","track-people-and-relationships"],"portable_brief":{"goal":"Builds a sourced account plan that keeps goals, relationships, risks and next moves in one reviewable place.","method_outline":["Collect dated account facts with per-field provenance.","Separate knowns, unknowns and recommendations.","Preview any saved plan and read it back after confirmation."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Important claims cite their source and date.","No account write occurs without an exact confirmed preview."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Create or update strategic account plan","title":"Account Plan","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Builds a sourced account plan that keeps goals, relationships, risks and next moves in one reviewable place."},{"availability":"dormant","capability_class":"active-skill","capability_id":"call-prep","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","privacy-minimal-disclosure","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/sales/call-prep/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","capture-without-friction","track-people-and-relationships"],"portable_brief":{"goal":"Turns current relationship, account and meeting evidence into a concise call brief without inventing intent.","method_outline":["Time-box and date the approved inputs.","Surface objectives, context and honest unknowns.","Draft questions and a read-only brief."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every material point has a source or an unknown label.","The brief does not claim another person's intent."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Prepare a sourced, read-only brief for a person or account call","title":"Call Prep","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Turns current relationship, account and meeting evidence into a concise call brief without inventing intent."},{"availability":"dormant","capability_class":"active-skill","capability_id":"deal-review","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/sales/deal-review/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","manage-tasks-reliably"],"portable_brief":{"goal":"Reviews deal evidence, value coverage and dated activity so pipeline attention goes to the right places.","method_outline":["Read canonical deal values and activity dates.","Keep unchecked and unknown-value deals visible.","Calculate only over a disclosed denominator."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Totals exclude unknown values instead of treating them as zero.","Coverage names checked and unchecked deals."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Review active deals from canonical activity evidence and surface unknowns","title":"Deal Review","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Reviews deal evidence, value coverage and dated activity so pipeline attention goes to the right places."},{"availability":"dormant","capability_class":"active-skill","capability_id":"pipeline-health","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/sales/pipeline-health/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Checks pipeline coverage, stage movement and forecast assumptions against configured sales definitions.","method_outline":["Confirm stages, probabilities, targets and period.","Distinguish missing data from zero.","Show sourced benchmarks, denominators and arithmetic."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every percentage can be recomputed from shown inputs.","Missing configuration returns an unknown result."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Analyze pipeline coverage and forecast confidence from configured sales definitions","title":"Pipeline Health","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Checks pipeline coverage, stage movement and forecast assumptions against configured sales definitions."},{"availability":"dormant","capability_class":"active-skill","capability_id":"customer-intel","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/product/customer-intel/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Synthesizes dated customer evidence into traceable themes while preserving quotes, contradictions and weak-signal limits.","method_outline":["Build a source-ID and date ledger.","Deduplicate repeated evidence without dropping provenance.","Return insufficient evidence when the record cannot support a theme."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Quotes remain faithful to their source.","Contradictory evidence stays visible."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Synthesize recent customer feedback and pain points","title":"Customer Intel","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Synthesizes dated customer evidence into traceable themes while preserving quotes, contradictions and weak-signal limits."},{"availability":"dormant","capability_class":"active-skill","capability_id":"feature-decision","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/product/feature-decision/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Frames an evidence-backed feature recommendation while keeping the human decision and prior record intact.","method_outline":["Gather outcomes, constraints, effort evidence and unknowns.","Compare alternatives and make a labelled recommendation.","Preview a proposed record and preserve or explicitly supersede earlier decisions."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The recommendation is not presented as an accepted decision.","Any persisted record reads back to the confirmed preview."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Framework for making feature prioritization decisions","title":"Feature Decision","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Frames an evidence-backed feature recommendation while keeping the human decision and prior record intact."},{"availability":"dormant","capability_class":"active-skill","capability_id":"roadmap","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/product/roadmap/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","start-each-day-focused"],"portable_brief":{"goal":"Builds a roadmap view from canonical dated status evidence, with disclosed status coverage and honest unknowns.","method_outline":["Read canonical goals, initiatives and status dates.","Keep unknown distinct from blocked.","Reconcile status counts over a declared cohort and cite the evidence."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every status has a source and freshness date.","Excluded or unknown work is shown beside the denominator."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Review roadmap status, evidence freshness, blockers, and alignment","title":"Roadmap","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Builds a roadmap view from canonical dated status evidence, with disclosed status coverage and honest unknowns."},{"availability":"dormant","capability_class":"active-skill","capability_id":"audience-intel","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/marketing/audience-intel/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Finds evidence-backed audience patterns without turning repeated anecdotes into invented personas.","method_outline":["Time-box and deduplicate the evidence ledger.","Compare segments, quotes and contradictions.","Label observed patterns separately from inference."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every audience claim cites quote, source and date.","Insufficient evidence produces an honest limited result."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when synthesizing dated customer conversations, feedback, or behavior evidence into audience or persona insight, especially when sources are numerous, repeated, time-bounded, or disagree.","title":"Audience Intel","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Finds evidence-backed audience patterns without turning repeated anecdotes into invented personas."},{"availability":"dormant","capability_class":"active-skill","capability_id":"campaign-review","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability","context-orientation"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/marketing/campaign-review/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","reflect-and-improve-continuously"],"portable_brief":{"goal":"Turns campaign goals, comparable actuals and attribution limits into reusable learning.","method_outline":["Establish the goal, baseline and comparable period.","Normalize target and actual metrics.","Separate correlation, causation, hypotheses and missing data."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every result cites its source and denominator.","Any saved review is previewed, confirmed and read back."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when a completed or in-flight marketing campaign needs an evidence-backed review of its goal, baseline, targets, actuals, or learnings.","title":"Campaign Review","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Turns campaign goals, comparable actuals and attribution limits into reusable learning."},{"availability":"dormant","capability_class":"active-skill","capability_id":"content-calendar","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/marketing/content-calendar/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","start-each-day-focused"],"portable_brief":{"goal":"Builds a dated content inventory that separates commitments from ideas and exposes collisions, gaps and undated work.","method_outline":["Define the period, timezone and canonical status evidence.","Detect duplicate items and date collisions.","Report committed, idea and undated buckets separately."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["No date, status or coverage percentage is inferred.","Any calendar change requires a confirmed preview."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when inventorying content commitments, ideas, and schedule coverage for a specified period and timezone.","title":"Content Calendar","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Builds a dated content inventory that separates commitments from ideas and exposes collisions, gaps and undated work."},{"availability":"dormant","capability_class":"active-skill","capability_id":"messaging-audit","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","compounding-correctability","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/marketing/messaging-audit/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Compares current messaging with a cited approved baseline and distinguishes drift from intentional variation.","method_outline":["Select and date the canonical baseline.","Normalize terms by audience and channel.","Classify contradictions, intentional variants, stale copy and unsupported claims."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The source-date matrix can be traced to each finding.","No copy is changed without human confirmation."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when comparing product or campaign messaging across content against a cited canonical baseline and its supporting evidence.","title":"Messaging Audit","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Compares current messaging with a cited approved baseline and distinguishes drift from intentional variation."},{"availability":"dormant","capability_class":"active-skill","capability_id":"architecture-decision","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/engineering/architecture-decision/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Compares architecture options and records an accepted choice only after the named human authority decides.","method_outline":["Collect constraints, evidence and alternatives.","Compare consequences and trade-offs.","Keep proposed, accepted and superseded ADR states distinct."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The record names decision authority and sources.","History is appended or superseded, never silently rewritten."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when a system or design choice needs an evidence-backed ADR, explicit alternatives and trade-offs, or review of proposed, accepted, or superseded decision history.","title":"Architecture Decision","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Compares architecture options and records an accepted choice only after the named human authority decides."},{"availability":"dormant","capability_class":"active-skill","capability_id":"incident-review","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","compounding-correctability","honest-health-observability","safe-change-recovery"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/engineering/incident-review/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","evolve-the-system-itself","reflect-and-improve-continuously"],"portable_brief":{"goal":"Creates a blameless, evidence-led incident review with a cited timeline and verifiable prevention work.","method_outline":["Build a timezone-aware fact timeline.","Separate facts, hypotheses and contradictions.","Assign prevention actions only from confirmed ownership and proof."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Unknown causes and owners remain explicit.","Follow-up checks name evidence of prevention."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when a service or operational incident needs a cited, timezone-aware timeline, blameless learning review, or prevention actions with accountable follow-up.","title":"Incident Review","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Creates a blameless, evidence-led incident review with a cited timeline and verifiable prevention work."},{"availability":"dormant","capability_class":"active-skill","capability_id":"tech-debt","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/engineering/tech-debt/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","evolve-the-system-itself","start-each-day-focused"],"portable_brief":{"goal":"Creates a deduplicated, evidence-linked technical-debt inventory with honest risk, effort and confidence.","method_outline":["Link code or operational evidence and first-seen dates.","Separate impact, effort, confidence and cost of delay.","Escalate security evidence through the approved path."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Age is never guessed from an undated mention.","Prioritisation retains its evidence and uncertainty."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when technical debt needs linked code or operational evidence, deduplication, first-seen provenance, or impact, effort, confidence, and cost-of-delay prioritization.","title":"Tech Debt","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Creates a deduplicated, evidence-linked technical-debt inventory with honest risk, effort and confidence."},{"availability":"dormant","capability_class":"active-skill","capability_id":"board-prep","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","privacy-minimal-disclosure","scoped-agency-human-control","honest-health-observability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/finance/board-prep/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Builds a reconciled, dated financial narrative and question set as a draft for authorised human review.","method_outline":["Set the as-of date, source hierarchy, unit and currency.","Reconcile actuals and expose forecast limits.","Draft the narrative and likely questions without approving or sending it."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Totals reconcile to cited sources.","Unknowns and forecast assumptions remain visible."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when preparing a finance draft for a board or leadership review from dated actuals, budgets, forecasts, cash data, and decision context. Not for detailed line-item variance analysis; use variance-analysis.","title":"Board Prep","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Builds a reconciled, dated financial narrative and question set as a draft for authorised human review."},{"availability":"dormant","capability_class":"active-skill","capability_id":"close-status","changed_in":[],"compatibility":{"foundation_capabilities":["honest-health-observability","durable-memory-provenance","context-orientation"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/finance/close-status/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","manage-tasks-reliably"],"portable_brief":{"goal":"Shows month-end close progress, blockers and critical path from the authoritative checklist rather than guessed status.","method_outline":["Load the approved checklist and as-of date.","Count complete items over the explicit denominator.","Derive dependencies and critical path while separating blocked, unknown and not started."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Completion can be recomputed from counted evidence.","No missing state becomes complete by inference."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when reporting the evidence-backed status of a named month-end or quarter-end close, its blockers, counted completion, and dependency path. Not for explaining budget variances; use variance-analysis.","title":"Close Status","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Shows month-end close progress, blockers and critical path from the authoritative checklist rather than guessed status."},{"availability":"dormant","capability_class":"active-skill","capability_id":"variance-analysis","changed_in":[],"compatibility":{"foundation_capabilities":["durable-memory-provenance","honest-health-observability","context-orientation"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/finance/variance-analysis/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","reflect-and-improve-continuously"],"portable_brief":{"goal":"Explains reconciled actual-versus-plan differences with validated formulas, materiality and honest causal limits.","method_outline":["Normalize units, signs and comparable periods.","Validate formulas, materiality and reconciled totals.","Label timing or permanent causes as evidenced, hypothesised or unknown."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Shown arithmetic reproduces each variance.","Unsupported causal explanations remain hypotheses."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when explaining a dated actual-versus-budget or actual-versus-forecast variance for a comparable finance period. Not for tracking close checklist completion; use close-status.","title":"Variance Analysis","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Explains reconciled actual-versus-plan differences with validated formulas, materiality and honest causal limits."},{"availability":"dormant","capability_class":"active-skill","capability_id":"expansion-opportunities","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/customer-success/expansion-opportunities/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","track-people-and-relationships"],"portable_brief":{"goal":"Finds account expansion hypotheses while keeping customer evidence, expressed need, fit and speculation separate.","method_outline":["Gather dated account evidence and expressed needs.","Assess fit without inventing value or likelihood.","Keep CRM changes, outreach and commercial action behind human approval."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every hypothesis shows its evidence and confidence.","No recommendation becomes pipeline or customer communication automatically."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when reviewing customer accounts for evidence-backed expansion hypotheses based on current usage, product fit, and expressed needs. Not for renewal strategy or negotiation; use renewal-prep.","title":"Expansion Opportunities","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Finds account expansion hypotheses while keeping customer evidence, expressed need, fit and speculation separate."},{"availability":"dormant","capability_class":"active-skill","capability_id":"health-score","changed_in":[],"compatibility":{"foundation_capabilities":["honest-health-observability","context-orientation","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/customer-success/health-score/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","track-people-and-relationships"],"portable_brief":{"goal":"Applies a configured account-health rubric to dated inputs, or returns not scored when honest scoring is impossible.","method_outline":["Confirm the scoring rubric and data freshness.","Calculate only from permitted dated inputs.","Keep unknown distinct from red or green and review signals when not scored."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["The score can be reproduced from the configured rubric.","Silence alone never becomes churn risk."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when reviewing customer-account health with a configured scoring rubric and dated inputs, or when reporting why a portfolio cannot yet be scored. Not for finding expansion opportunities; use expansion-opportunities.","title":"Health Score","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Applies a configured account-health rubric to dated inputs, or returns not scored when honest scoring is impossible."},{"availability":"dormant","capability_class":"active-skill","capability_id":"renewal-prep","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/customer-success/renewal-prep/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","track-people-and-relationships"],"portable_brief":{"goal":"Prepares a sourced renewal brief from contract, ARR, dated outcomes and explicit risks without making commercial commitments.","method_outline":["Cite contract, ARR, renewal date and outcome evidence.","Separate risk from unknown and recommendations from decisions.","Keep pricing and customer communication human-authorised."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every value claim has a dated source.","The brief sends nothing and changes no commercial record."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when preparing an evidence-backed brief for an upcoming customer renewal from contract, ARR, dated outcomes, usage, and risk evidence. Not for health scoring; use health-score.","title":"Renewal Prep","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Prepares a sourced renewal brief from contract, ARR, dated outcomes and explicit risks without making commercial commitments."},{"availability":"dormant","capability_class":"active-skill","capability_id":"metrics-review","changed_in":[],"compatibility":{"foundation_capabilities":["honest-health-observability","context-orientation","durable-memory-provenance"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/operations/metrics-review/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","evolve-the-system-itself"],"portable_brief":{"goal":"Reviews comparable operational metrics and validates anomalies before interpreting performance.","method_outline":["Define each metric, unit, window, source, baseline and target.","Check freshness and comparability.","Validate anomalies before offering a non-causal interpretation."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every number has a definition and source date.","Missing or incomparable data stays unknown."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when a business or operational metric needs definition and source provenance checked, freshness and comparability validated, or an anomaly reviewed against a baseline and target.","title":"Metrics Review","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Reviews comparable operational metrics and validates anomalies before interpreting performance."},{"availability":"dormant","capability_class":"active-skill","capability_id":"process-audit","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/operations/process-audit/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","reflect-and-improve-continuously"],"portable_brief":{"goal":"Maps a bounded process from observed samples, then tests bottleneck improvements with measurable outcomes.","method_outline":["Define process start, end, owner and outcome.","Sample observed queues, handoffs, rework and failures.","Propose a controlled experiment with a success measure."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Claims disclose the observed sample and limits.","An experiment is not called successful before measurement."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when an operational process needs its start, end, owner, outcome, representative sample, measured queues or handoffs, bottleneck evidence, or controlled improvement experiment made explicit.","title":"Process Audit","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Maps a bounded process from observed samples, then tests bottleneck improvements with measurable outcomes."},{"availability":"dormant","capability_class":"active-skill","capability_id":"design-review","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/design/design-review/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track"],"portable_brief":{"goal":"Prepares or documents a design review with versioned artifacts, traceable requirements and explicit decision authority.","method_outline":["Choose preparation or documentation mode.","Identify artifact versions, requirements and evidence.","Keep recommendations distinct from authorised decisions."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every finding points to a versioned artifact and requirement.","A decision record names who accepted it."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when a design artifact or revision needs a prepared review packet or an evidence-backed record of a review outcome, requirements, and decisions.","title":"Design Review","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Prepares or documents a design review with versioned artifacts, traceable requirements and explicit decision authority."},{"availability":"dormant","capability_class":"active-skill","capability_id":"design-system-audit","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","honest-health-observability","compounding-correctability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","role-source-access","capability-adoption"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":false,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_role_skill_contracts.py","summary":"The shipped instructions meet the reviewed role-specific evidence and depth contract."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_lifecycle_official_capabilities.py","summary":"Lifecycle tests support adoption, replan and rewind of official capability payloads."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/design/design-system-audit/SKILL.md","summary":"The official lifecycle catalogue pins this dormant role skill to the release bytes."}],"impact_tier":"medium","jobs":["keep-projects-on-track","evolve-the-system-itself"],"portable_brief":{"goal":"Measures design-system use against canonical components and tokens with a declared sample and denominator.","method_outline":["Select canonical components, tokens and a representative sample.","Calculate adoption over a disclosed denominator.","Separate accidental deviations from intentional exceptions."],"rollback_advice":"Rewind or remove the adopted role skill through the capability manager; keep the person's source material and prior records untouched.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Coverage and adoption can be recomputed from shown inputs.","Exceptions retain owner, reason and evidence."]},"prerequisites":["Adopt this dormant role skill through Dex's capability manager before using it.","Give the host access only to the approved role sources named by the workflow."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Use when assessing use of named design-system components or tokens across a defined sample of product artifacts, including adoption and deviation questions.","title":"Design System Audit","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Measures design-system use against canonical components and tokens with a declared sample and denominator."},{"availability":"dormant","capability_class":"active-skill","capability_id":"career-setup","changed_in":[],"compatibility":{"foundation_capabilities":["privacy-minimal-disclosure","ownership-portability","scoped-agency-human-control","safe-change-recovery"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","career-room-enabled","room-capability-manager"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":true,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions close the reviewed evidence, authority and recovery gaps."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_capabilities.py","summary":"Room activation verifies release-owned skill identity before changing profile or files."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/capabilities/career/skills/career-setup/SKILL.md","summary":"The release ships this room skill as the source used when the room is enabled."}],"impact_tier":"high","jobs":["track-career-growth"],"portable_brief":{"goal":"Sets up the career room and its consented evidence space while verifying the room, hooks and connected tools honestly.","method_outline":["Preview the canonical career evidence paths and sensitive-data boundary.","Enable only after consent.","Verify room, hook and MCP state and surface capture failures."],"rollback_advice":"Disable the room through the capability manager; preserve the person's room content and remove only release-owned surfaced skill copies.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["All evidence paths use the portable room contract.","Failed setup leaves a clear recovery state."]},"prerequisites":["Enable the career room; its skills are installed as one room bundle, not adopted independently.","Keep the room's approved source and privacy boundaries available to the host."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Initialize career development system (job description, ladder, reviews, goals)","title":"Career Setup","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Sets up the career room and its consented evidence space while verifying the room, hooks and connected tools honestly."},{"availability":"dormant","capability_class":"active-skill","capability_id":"career-coach","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","compounding-correctability","privacy-minimal-disclosure"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","career-room-enabled","room-capability-manager"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions close the reviewed evidence, authority and recovery gaps."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_capabilities.py","summary":"Room activation verifies release-owned skill identity before changing profile or files."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/capabilities/career/skills/career-coach/SKILL.md","summary":"The release ships this room skill as the source used when the room is enabled."}],"impact_tier":"high","jobs":["track-career-growth","reflect-and-improve-continuously"],"portable_brief":{"goal":"Turns sourced career evidence into reflective coaching while keeping uncertainty, HR limits and save consent explicit.","method_outline":["Choose the coaching mode and inspect consented evidence.","Separate missing evidence from missing competency and label confidence.","Preview and confirm any saved reflection."],"rollback_advice":"Disable the room through the capability manager; preserve the person's room content and remove only release-owned surfaced skill copies.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Claims cite evidence and uncertainty.","The coach does not impersonate HR or a manager."]},"prerequisites":["Enable the career room; its skills are installed as one room bundle, not adopted independently.","Keep the room's approved source and privacy boundaries available to the host."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Personal career coach with 4 modes: weekly reports, monthly reflections, self-reviews, promotion assessments","title":"Career Coach","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Turns sourced career evidence into reflective coaching while keeping uncertainty, HR limits and save consent explicit."},{"availability":"dormant","capability_class":"active-skill","capability_id":"resume-builder","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","privacy-minimal-disclosure","ownership-portability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","career-room-enabled","room-capability-manager"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions close the reviewed evidence, authority and recovery gaps."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_capabilities.py","summary":"Room activation verifies release-owned skill identity before changing profile or files."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/capabilities/career/skills/resume-builder/SKILL.md","summary":"The release ships this room skill as the source used when the room is enabled."}],"impact_tier":"high","jobs":["track-career-growth"],"portable_brief":{"goal":"Builds a truthful, portable resume from sourced evidence and verifies the rendered result before claiming pagination.","method_outline":["Gather cited outcomes without inventing metrics.","Label any user-supplied estimate.","Render-check pages and separately confirm every cross-file write."],"rollback_advice":"Disable the room through the capability manager; preserve the person's room content and remove only release-owned surfaced skill copies.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every claim maps to evidence or an explicit supplied estimate.","Pagination is claimed only after rendering."]},"prerequisites":["Enable the career room; its skills are installed as one room bundle, not adopted independently.","Keep the room's approved source and privacy boundaries available to the host."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Build resume and LinkedIn profile through guided interview","title":"Resume Builder","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Builds a truthful, portable resume from sourced evidence and verifies the rendered result before claiming pagination."},{"availability":"dormant","capability_class":"active-skill","capability_id":"quarter-plan","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","scoped-agency-human-control","safe-change-recovery"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","quarter-goals-room-enabled","room-capability-manager"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions close the reviewed evidence, authority and recovery gaps."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_capabilities.py","summary":"Room activation verifies release-owned skill identity before changing profile or files."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/capabilities/quarter_goals/skills/quarter-plan/SKILL.md","summary":"The release ships this room skill as the source used when the room is enabled."}],"impact_tier":"high","jobs":["start-each-day-focused"],"portable_brief":{"goal":"Builds a quarter plan across the correct fiscal boundary with previewed, conflict-safe and verified writes.","method_outline":["Confirm fiscal-quarter dates and current goals.","Preview every archive, move or goal mutation separately.","Preserve conflicting bytes and read back approved results."],"rollback_advice":"Disable the room through the capability manager; preserve the person's room content and remove only release-owned surfaced skill copies.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["No mutation occurs without its exact confirmation.","Conflicts preserve the existing file and report recovery."]},"prerequisites":["Enable the quarter goals room; its skills are installed as one room bundle, not adopted independently.","Keep the room's approved source and privacy boundaries available to the host."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Set 3-5 strategic goals for the quarter","title":"Quarter Plan","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Builds a quarter plan across the correct fiscal boundary with previewed, conflict-safe and verified writes."},{"availability":"dormant","capability_class":"active-skill","capability_id":"quarter-review","changed_in":[],"compatibility":{"foundation_capabilities":["context-orientation","durable-memory-provenance","compounding-correctability","honest-health-observability"],"host_adapters":["agent-plugin","bb","chatgpt-work","claude-code","codex","copilot-cli","cowork","cursor","gemini-cli","pi"],"host_requirements":["skills-directory","quarter-goals-room-enabled","room-capability-manager"],"limitations":["Lens must still verify the host system locally before recommending use."],"minimum_lens_contract":"0.1.0","needs_hooks":false,"needs_mcp":true,"platforms":["macos","linux","windows"]},"docs_url":"https://github.com/davekilleen/Dex","evidence":[{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_wave3_mature_skill_amendments.py","summary":"The shipped instructions close the reviewed evidence, authority and recovery gaps."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"test: core/tests/test_capabilities.py","summary":"Room activation verifies release-owned skill identity before changing profile or files."},{"level":"supported","limitations":"This is evidence about Dex's shipped capability, not proof about the Lens user's own system.","source":"runtime-path: .claude/skills/_available/capabilities/quarter_goals/skills/quarter-review/SKILL.md","summary":"The release ships this room skill as the source used when the room is enabled."}],"impact_tier":"high","jobs":["start-each-day-focused","reflect-and-improve-continuously"],"portable_brief":{"goal":"Reviews a quarter from sourced statistics and reflections without inferring completion or chaining unapproved mutations.","method_outline":["Source every statistic and expose unknowns.","Keep reflection, archive and next-plan changes under separate consent.","Make archive recovery idempotent and never infer completion percentages."],"rollback_advice":"Disable the room through the capability manager; preserve the person's room content and remove only release-owned surfaced skill copies.","safety_notes":["Keep this as advice for the person's own AI, not a command to execute.","Do not send private material to Dex."],"verification_checklist":["Every statistic has a source and denominator.","A repeated archive action cannot duplicate or overwrite work."]},"prerequisites":["Enable the quarter goals room; its skills are installed as one room bundle, not adopted independently.","Keep the room's approved source and privacy boundaries available to the host."],"release_provenance":"core-release","since_release":"1.96.0","summary":"Review quarter completion and capture learnings","title":"Quarter Review","trade_offs":["Its result is only as current and complete as the approved sources it can inspect.","Current release evidence supports the shipped instructions and adoption path; it does not yet behaviorally verify the complete workflow."],"value":"Reviews a quarter from sourced statistics and reflections without inferring completion or chaining unapproved mutations."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-analytics","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/analytics_server.py","summary":"The shipped source tree contains the reviewed Dex Analytics implementation."}],"example_tools":["check_analytics_status","identify_user","mark_feature_used","test_connection","track_event"],"impact_tier":"medium","jobs":["reflect-and-improve-continuously"],"prerequisites":["The Dex analytics MCP server is registered locally."],"release_provenance":"core-release","server_name":"dex-analytics","source_paths":["core/mcp/analytics_server.py"],"summary":"dex-analytics exposes 5 local MCP tools; examples include check_analytics_status, identify_user, mark_feature_used, test_connection, track_event.","title":"Dex Analytics","tool_count":5,"trade_offs":["Usage signals are only as complete as the events the local system records."],"value":"Shows which Dex workflows are being used so the system can improve from real behavior."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-calendar-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/calendar_server.py","summary":"The shipped source tree contains the reviewed Dex Calendar MCP implementation."}],"example_tools":["calendar_create_event","calendar_delete_event","calendar_get_events","calendar_get_events_with_attendees","calendar_get_next_event"],"impact_tier":"high","jobs":["start-each-day-focused","track-people-and-relationships"],"prerequisites":["Local calendar access is authorized and the server is registered."],"release_provenance":"core-release","server_name":"dex-calendar-mcp","source_paths":["core/mcp/calendar_server.py"],"summary":"dex-calendar-mcp exposes 15 local MCP tools; examples include calendar_create_event, calendar_delete_event, calendar_get_events, calendar_get_events_with_attendees, calendar_get_next_event.","title":"Dex Calendar MCP","tool_count":15,"trade_offs":["Calendar results depend on operating-system permissions and the freshness of local calendars."],"value":"Makes calendar pressure and meeting context available to planning and preparation workflows."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-career-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/career_server.py","summary":"The shipped source tree contains the reviewed Dex Career MCP implementation."}],"example_tools":["analyze_coverage","generate_evidence_from_work","parse_ladder","promotion_readiness_score","scan_evidence"],"impact_tier":"medium","jobs":["track-career-growth"],"prerequisites":["The career capability is enabled and its local data paths exist."],"release_provenance":"core-release","server_name":"dex-career-mcp","source_paths":["core/mcp/career_server.py"],"summary":"dex-career-mcp exposes 8 local MCP tools; examples include analyze_coverage, generate_evidence_from_work, parse_ladder, promotion_readiness_score, scan_evidence.","title":"Dex Career MCP","tool_count":8,"trade_offs":["Career outputs remain bounded by the evidence the person has chosen to capture."],"value":"Keeps career evidence and development work consented, sourced and reviewable."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-customization-migration-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/customization_migration_server.py","summary":"The shipped source tree contains the reviewed Dex Customization Migration MCP implementation."}],"example_tools":["assess_customizations","preview_customization_capsule","read_activation_status","read_customization_capsule_blob","read_customization_capsule_section"],"impact_tier":"medium","jobs":["evolve-the-system-itself"],"prerequisites":["A compatible migration plan and lifecycle service are available."],"release_provenance":"core-release","server_name":"dex-customization-migration-mcp","source_paths":["core/mcp/customization_migration_server.py"],"summary":"dex-customization-migration-mcp exposes 7 local MCP tools; examples include assess_customizations, preview_customization_capsule, read_activation_status, read_customization_capsule_blob, read_customization_capsule_section.","title":"Dex Customization Migration MCP","tool_count":7,"trade_offs":["Migration remains confirm-gated and may refuse changes that cannot be safely reversed."],"value":"Moves approved customizations through Dex's receipt-backed lifecycle instead of editing the vault ad hoc."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-granola-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/granola_server.py","summary":"The shipped source tree contains the reviewed Dex Granola MCP implementation."}],"example_tools":["granola_check_available","granola_get_extent","granola_get_meeting_details","granola_get_recent_meetings","granola_get_today_meetings"],"impact_tier":"high","jobs":["capture-without-friction","track-people-and-relationships"],"prerequisites":["Granola access is connected and authorized by the person."],"release_provenance":"core-release","server_name":"dex-granola-mcp","source_paths":["core/mcp/granola_server.py"],"summary":"dex-granola-mcp exposes 6 local MCP tools; examples include granola_check_available, granola_get_extent, granola_get_meeting_details, granola_get_recent_meetings, granola_get_today_meetings.","title":"Dex Granola MCP","tool_count":6,"trade_offs":["Meeting coverage depends on the upstream Granola account and transcript availability."],"value":"Brings meeting records into Dex for processing without relying on manual transcript copying."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-improvements-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/dex_improvements_server.py","summary":"The shipped source tree contains the reviewed Dex Improvements MCP implementation."}],"example_tools":["capture_idea","enrich_idea","get_backlog_stats","get_idea_details","list_ideas"],"impact_tier":"high","jobs":["reflect-and-improve-continuously","evolve-the-system-itself"],"prerequisites":["The local improvements store is available."],"release_provenance":"core-release","server_name":"dex-improvements-mcp","source_paths":["core/mcp/dex_improvements_server.py"],"summary":"dex-improvements-mcp exposes 9 local MCP tools; examples include capture_idea, enrich_idea, get_backlog_stats, get_idea_details, list_ideas.","title":"Dex Improvements MCP","tool_count":9,"trade_offs":["Ranking is advisory and still needs a person to choose what should change."],"value":"Turns observed friction into a ranked, inspectable backlog of system improvements."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-onboarding-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/onboarding_server.py","summary":"The shipped source tree contains the reviewed Dex Onboarding MCP implementation."}],"example_tools":["apply_confirmed_onboarding_context","check_onboarding_complete","cleanup_qa_session","finalize_onboarding","generate_nudge_calendar"],"impact_tier":"high","jobs":["evolve-the-system-itself"],"prerequisites":["Dex is running from a writable local vault during onboarding."],"release_provenance":"core-release","server_name":"dex-onboarding-mcp","source_paths":["core/mcp/onboarding_server.py"],"summary":"dex-onboarding-mcp exposes 19 local MCP tools; examples include apply_confirmed_onboarding_context, check_onboarding_complete, cleanup_qa_session, finalize_onboarding, generate_nudge_calendar.","title":"Dex Onboarding MCP","tool_count":19,"trade_offs":["Setup quality depends on the person supplying accurate preferences and granting chosen permissions."],"value":"Coordinates first-run setup through explicit, locally verified onboarding steps."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-pipedrive-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/integrations/pipedrive/pipedrive_server.py","summary":"The shipped source tree contains the reviewed Dex Pipedrive MCP implementation."}],"example_tools":["pipedrive_add_deal_activity","pipedrive_add_deal_note","pipedrive_create_deal","pipedrive_create_org","pipedrive_find_deal"],"impact_tier":"high","jobs":["keep-projects-on-track","track-people-and-relationships"],"prerequisites":["Pipedrive is explicitly connected and its local server is registered."],"release_provenance":"core-release","server_name":"dex-pipedrive-mcp","source_paths":["core/integrations/pipedrive/pipedrive_server.py"],"summary":"dex-pipedrive-mcp exposes 15 local MCP tools; examples include pipedrive_add_deal_activity, pipedrive_add_deal_note, pipedrive_create_deal, pipedrive_create_org, pipedrive_find_deal.","title":"Dex Pipedrive MCP","tool_count":15,"trade_offs":["External records depend on Pipedrive availability, and writes remain opt-in and confirmation-gated."],"value":"Connects customer relationship data to Dex so deal context can support planning and follow-through."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-resume-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/resume_server.py","summary":"The shipped source tree contains the reviewed Dex Resume MCP implementation."}],"example_tools":["add_role","compile_resume","export_resume","extract_achievements","generate_linkedin"],"impact_tier":"medium","jobs":["track-career-growth"],"prerequisites":["Consented career evidence exists in the local career space."],"release_provenance":"core-release","server_name":"dex-resume-mcp","source_paths":["core/mcp/resume_server.py"],"summary":"dex-resume-mcp exposes 12 local MCP tools; examples include add_role, compile_resume, export_resume, extract_achievements, generate_linkedin.","title":"Dex Resume MCP","tool_count":12,"trade_offs":["The server cannot fill evidence gaps without the person's review and additional source material."],"value":"Builds truthful application material from consented career evidence rather than invented claims."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-session-memory","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/session_memory_server.py","summary":"The shipped source tree contains the reviewed Dex Session Memory implementation."}],"example_tools":["get_entity_timeline","get_observation_timeline","get_recent_decisions","get_recent_tool_usage","get_session_context"],"impact_tier":"high","jobs":["reflect-and-improve-continuously","keep-projects-on-track"],"prerequisites":["The local session-memory store is available."],"release_provenance":"core-release","server_name":"dex-session-memory","source_paths":["core/mcp/session_memory_server.py"],"summary":"dex-session-memory exposes 8 local MCP tools; examples include get_entity_timeline, get_observation_timeline, get_recent_decisions, get_recent_tool_usage, get_session_context.","title":"Dex Session Memory","tool_count":8,"trade_offs":["Remembered context can become stale and must retain clear provenance."],"value":"Carries sourced context across sessions so repeated work does not restart from an empty chat."},{"availability":"active","capability_class":"mcp-server","capability_id":"dex-work-mcp","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/mcp/work_server.py","summary":"The shipped source tree contains the reviewed Dex Work MCP implementation."}],"example_tools":["analyze_calendar_capacity","boot_today","build_company_index","build_people_index","capture_skill_rating"],"impact_tier":"core","jobs":["manage-tasks-reliably","keep-projects-on-track","track-people-and-relationships"],"prerequisites":["A Dex vault and its portable path contract are available."],"release_provenance":"core-release","server_name":"dex-work-mcp","source_paths":["core/mcp/work_server.py"],"summary":"dex-work-mcp exposes 53 local MCP tools; examples include analyze_calendar_capacity, boot_today, build_company_index, build_people_index, capture_skill_rating.","title":"Dex Work MCP","tool_count":53,"trade_offs":["Mutations remain bounded by confirmation, validation and the local vault's current structure."],"value":"Provides the validated task, project, person and company operations that core Dex workflows rely on."},{"automation_label":"com.dex.changelog-checker","availability":"active","cadence":"every 6 hours; also at load","capability_class":"scheduled-automation","capability_id":"dex-changelog-checker","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: .scripts/com.dex.changelog-checker.plist","summary":"The shipped source tree contains the reviewed Dex Changelog Checker implementation."}],"impact_tier":"medium","installer_path":".scripts/install-learning-automation.sh","jobs":["evolve-the-system-itself"],"prerequisites":["The learning automation launch agent is installed on macOS."],"program_target":"{{VAULT_PATH}}/.scripts/check-anthropic-changelog.cjs","release_provenance":"core-release","run_at_load":true,"source_paths":[".scripts/com.dex.changelog-checker.plist",".scripts/install-learning-automation.sh"],"summary":"Runs {{VAULT_PATH}}/.scripts/check-anthropic-changelog.cjs every 6 hours; also at load.","title":"Dex Changelog Checker","trade_offs":["The check is periodic, so upstream changes are not surfaced instantly."],"value":"Checks for relevant upstream capability changes several times a day without manual polling."},{"automation_label":"com.dex.learning-review","availability":"active","cadence":"daily at 17:00","capability_class":"scheduled-automation","capability_id":"dex-learning-review","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: .scripts/com.dex.learning-review.plist","summary":"The shipped source tree contains the reviewed Dex Learning Review implementation."}],"impact_tier":"high","installer_path":".scripts/install-learning-automation.sh","jobs":["reflect-and-improve-continuously"],"prerequisites":["The learning automation launch agent is installed on macOS."],"program_target":"{{VAULT_PATH}}/.scripts/learning-review-prompt.sh","release_provenance":"core-release","run_at_load":false,"source_paths":[".scripts/com.dex.learning-review.plist",".scripts/install-learning-automation.sh"],"summary":"Runs {{VAULT_PATH}}/.scripts/learning-review-prompt.sh daily at 17:00.","title":"Dex Learning Review","trade_offs":["A scheduled prompt still depends on the person choosing to review and adopt useful changes."],"value":"Prompts a daily review so observed friction can become durable learning."},{"automation_label":"com.dex.meeting-intel","availability":"active","cadence":"every 30 minutes; also at load","capability_class":"scheduled-automation","capability_id":"dex-meeting-intel","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: .scripts/meeting-intel/com.dex.meeting-intel.plist.template","summary":"The shipped source tree contains the reviewed Dex Meeting Intel implementation."}],"impact_tier":"high","installer_path":".scripts/meeting-intel/install-automation.sh","jobs":["capture-without-friction","track-people-and-relationships"],"prerequisites":["Granola is connected and the meeting-intelligence launch agent is installed on macOS."],"program_target":".scripts/meeting-intel/sync-from-granola.cjs","release_provenance":"core-release","run_at_load":true,"source_paths":[".scripts/meeting-intel/com.dex.meeting-intel.plist.template",".scripts/meeting-intel/install-automation.sh"],"summary":"Runs .scripts/meeting-intel/sync-from-granola.cjs every 30 minutes; also at load.","title":"Dex Meeting Intel","trade_offs":["Sync freshness depends on both the upstream service and the local machine being able to run the job."],"value":"Keeps Granola meeting material synchronized frequently enough for timely preparation and closeout."},{"automation_label":"com.dex.smoke-nightly","availability":"active","cadence":"daily at 03:15","capability_class":"scheduled-automation","capability_id":"dex-smoke-nightly","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: .scripts/com.dex.smoke-nightly.plist.template","summary":"The shipped source tree contains the reviewed Dex Smoke Nightly implementation."}],"impact_tier":"high","installer_path":".scripts/install-smoke-automation.sh","jobs":["evolve-the-system-itself"],"prerequisites":["The nightly smoke launch agent is installed on macOS."],"program_target":"__VAULT_PATH__/.scripts/nightly-smoke.sh","release_provenance":"core-release","run_at_load":false,"source_paths":[".scripts/com.dex.smoke-nightly.plist.template",".scripts/install-smoke-automation.sh"],"summary":"Runs __VAULT_PATH__/.scripts/nightly-smoke.sh daily at 03:15.","title":"Dex Smoke Nightly","trade_offs":["A nightly check can detect known failures but cannot prove every workflow is healthy."],"value":"Runs a nightly health smoke check so breakage can surface before a person depends on the system."},{"automation_label":"com.dex.vault-backup","availability":"active","cadence":"daily at a user-selected time","capability_class":"scheduled-automation","capability_id":"dex-vault-backup","evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/backup/install_backup_job.py","summary":"The shipped source tree contains the reviewed Dex Vault Backup implementation."}],"impact_tier":"core","installer_path":"core/backup/install_backup_job.py","jobs":["evolve-the-system-itself"],"prerequisites":["Backup setup is complete and its destination has been verified."],"program_target":"core/backup/backup_vault.py","release_provenance":"core-release","run_at_load":false,"source_paths":["core/backup/install_backup_job.py","core/backup/backup_vault.py"],"summary":"Runs core/backup/backup_vault.py daily at a user-selected time.","title":"Dex Vault Backup","trade_offs":["A schedule is not proof of recovery; the person must still test that a backup can be restored."],"value":"Creates a scheduled recovery copy of the person's vault at a time they choose."},{"availability":"parked","capability_class":"system-engine","capability_id":"connection-manager-engine","component_count":20,"evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/integrations/connection-manager/auth-context.cjs","summary":"The shipped source tree contains the reviewed Connection Manager Engine implementation."}],"example_components":["core/integrations/connection-manager/auth-context.cjs","core/integrations/connection-manager/broker-client.cjs","core/integrations/connection-manager/broker.cjs","core/integrations/connection-manager/catalog.cjs","core/integrations/connection-manager/connect.cjs"],"impact_tier":"high","jobs":["evolve-the-system-itself"],"prerequisites":["A reviewed person-facing doorway must be released before this engine can be used."],"release_provenance":"core-release","source_paths":["core/integrations/connection-manager/auth-context.cjs","core/integrations/connection-manager/broker-client.cjs","core/integrations/connection-manager/broker.cjs","core/integrations/connection-manager/catalog.cjs","core/integrations/connection-manager/connect.cjs","core/integrations/connection-manager/contract.cjs","core/integrations/connection-manager/dex-call.cjs","core/integrations/connection-manager/fs-safe.cjs","core/integrations/connection-manager/get-token.cjs","core/integrations/connection-manager/health.cjs","core/integrations/connection-manager/index.cjs","core/integrations/connection-manager/lib/connector-ledger.js","core/integrations/connection-manager/lib/connector-model.js","core/integrations/connection-manager/lib/connector-verify.js","core/integrations/connection-manager/lib/oauth-refresh.js","core/integrations/connection-manager/lib/rate-limit.js","core/integrations/connection-manager/oauth-flow.cjs","core/integrations/connection-manager/pinned-providers.cjs","core/integrations/connection-manager/presence.cjs","core/integrations/connection-manager/token-store.cjs"],"summary":"Groups 20 shipped source components. Parked: it is not wired into the live product.","title":"Connection Manager Engine","trade_offs":["The engine is shipped groundwork and must not be recommended as currently usable."],"value":"Provides local connection custody and provider metadata, but its person-facing doorway remains unavailable."},{"availability":"active","capability_class":"system-engine","capability_id":"entity-temperature-engine","component_count":9,"evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/entity_engine/__init__.py","summary":"The shipped source tree contains the reviewed Entity Temperature Engine implementation."}],"example_components":["core/entity_engine/__init__.py","core/entity_engine/cli.py","core/entity_engine/contract.py","core/entity_engine/cooling.py","core/entity_engine/index.py"],"impact_tier":"high","jobs":["track-people-and-relationships"],"prerequisites":["Entity indexing and relationship data are available locally."],"release_provenance":"core-release","source_paths":["core/entity_engine/__init__.py","core/entity_engine/cli.py","core/entity_engine/contract.py","core/entity_engine/cooling.py","core/entity_engine/index.py","core/entity_engine/relationships.py","core/entity_engine/reroute.py","core/entity_engine/temperature.py","core/entity_engine/write.py"],"summary":"Groups 9 shipped source components.","title":"Entity Temperature Engine","trade_offs":["Temperature is a prioritization signal, not an objective measure of relationship importance."],"value":"Keeps people and entity context warm when it matters and cools stale signals over time."},{"availability":"active","capability_class":"system-engine","capability_id":"proactive-promise-engine","component_count":2,"evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/health/promises.py","summary":"The shipped source tree contains the reviewed Proactive Promise Engine implementation."}],"example_components":["core/health/promises.py","core/tests/test_health_promises.py"],"impact_tier":"core","jobs":["manage-tasks-reliably","evolve-the-system-itself"],"prerequisites":["Dex Doctor can inspect the relevant local runtime evidence."],"release_provenance":"core-release","source_paths":["core/health/promises.py","core/tests/test_health_promises.py"],"summary":"Groups 2 shipped source components.","title":"Proactive Promise Engine","trade_offs":["A promise only detects the failure modes its evidence and thresholds explicitly cover."],"value":"Defines the concrete promises Dex health checks use to catch silent reliability failures."},{"availability":"parked","capability_class":"system-engine","capability_id":"ritual-intelligence-engine","component_count":22,"evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: core/ritual_intelligence/__init__.py","summary":"The shipped source tree contains the reviewed Ritual Intelligence Engine implementation."}],"example_components":["core/ritual_intelligence/__init__.py","core/ritual_intelligence/__main__.py","core/ritual_intelligence/actions.py","core/ritual_intelligence/brief_generate.py","core/ritual_intelligence/calendar_ingest.py"],"impact_tier":"high","jobs":["start-each-day-focused","capture-without-friction"],"prerequisites":["The parked engine would need an approved live integration before it could serve users."],"release_provenance":"core-release","source_paths":["core/ritual_intelligence/__init__.py","core/ritual_intelligence/__main__.py","core/ritual_intelligence/actions.py","core/ritual_intelligence/brief_generate.py","core/ritual_intelligence/calendar_ingest.py","core/ritual_intelligence/cli.py","core/ritual_intelligence/contact_promote.py","core/ritual_intelligence/contact_suggest.py","core/ritual_intelligence/corrections.py","core/ritual_intelligence/db.py","core/ritual_intelligence/manual_note_match.py","core/ritual_intelligence/matching.py","core/ritual_intelligence/meeting_intel_projection.py","core/ritual_intelligence/meeting_reconcile.py","core/ritual_intelligence/models.py","core/ritual_intelligence/prep_state.py","core/ritual_intelligence/projection_write.py","core/ritual_intelligence/ritual_match.py","core/ritual_intelligence/service.py","core/ritual_intelligence/transcript_ingest.py","core/ritual_intelligence/transcript_reconcile.py","core/ritual_intelligence/transcript_store.py"],"summary":"Groups 22 shipped source components. Parked: it is not wired into the live product.","title":"Ritual Intelligence Engine","trade_offs":["This capability is parked and must not be presented as currently available."],"value":"Contains a richer meeting and ritual intelligence engine that is code-complete but not wired into the live product."},{"availability":"active","capability_class":"system-engine","capability_id":"session-hook-orchestration","component_count":32,"evidence":[{"level":"supported","limitations":"Source presence proves Dex ships the implementation, not that it is configured or healthy on a Lens user's system.","source":"runtime-path: .claude/hooks/README.md","summary":"The shipped source tree contains the reviewed Session Hook Orchestration implementation."}],"example_components":[".claude/hooks/README.md",".claude/hooks/adapters/jira.cjs",".claude/hooks/adapters/run.cjs",".claude/hooks/adapters/service-aliases.json",".claude/hooks/adapters/things.cjs"],"impact_tier":"core","jobs":["evolve-the-system-itself","start-each-day-focused"],"prerequisites":["Claude Code hooks are installed and enabled for the Dex vault."],"release_provenance":"core-release","source_paths":[".claude/hooks/README.md",".claude/hooks/adapters/jira.cjs",".claude/hooks/adapters/run.cjs",".claude/hooks/adapters/service-aliases.json",".claude/hooks/adapters/things.cjs",".claude/hooks/adapters/todoist.cjs",".claude/hooks/adapters/trello.cjs",".claude/hooks/career-evidence-capture.cjs",".claude/hooks/claude-composition-refresh.sh",".claude/hooks/company-context-injector.cjs",".claude/hooks/connection-health-checker.cjs",".claude/hooks/correction-capture.py",".claude/hooks/correction-capture.sh",".claude/hooks/daily-plan-quick-ref.cjs",".claude/hooks/dex-core-orientation.sh",".claude/hooks/dex-safety-guard.sh",".claude/hooks/ensure-mcp-user-scope.cjs",".claude/hooks/health-pulse.sh",".claude/hooks/integration-concierge.cjs",".claude/hooks/maintenance.cjs",".claude/hooks/meeting-cache-builder.cjs",".claude/hooks/meeting-queue-check.cjs",".claude/hooks/observation-recorder.py",".claude/hooks/paths.cjs",".claude/hooks/person-context-injector.cjs",".claude/hooks/post-meeting-person-update.cjs",".claude/hooks/session-clock.sh",".claude/hooks/session-end.sh",".claude/hooks/session-start.sh",".claude/hooks/skill-freshness.py",".claude/hooks/soft-promise-detector.py",".claude/hooks/vault-autocommit.cjs"],"summary":"Groups 32 shipped source components.","title":"Session Hook Orchestration","trade_offs":["Hook behavior depends on the host honoring the configured lifecycle events and local permissions."],"value":"Coordinates session startup, safety, context injection, maintenance and closeout around the user's work."}],"capability_families":[{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"dex-granola-mcp","component_type":"capability"},{"capability_id":"dex-meeting-intel","component_type":"capability"},{"capability_id":"granola-setup","component_type":"capability"},{"capability_id":"meeting-closeout","component_type":"capability"},{"capability_id":"meeting-prep","component_type":"capability"},{"capability_id":"process-meetings","component_type":"capability"}],"family_id":"meeting-follow-through","jobs":["capture-without-friction","track-people-and-relationships"],"member_capability_ids":["dex-granola-mcp","dex-meeting-intel","granola-setup","meeting-closeout","meeting-prep","process-meetings"],"outcome":"Meetings become notes, people context and tracked follow-up.","title":"Meeting follow-through"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"entity-temperature-engine","component_type":"capability"},{"capability_id":"relationship-radar","component_type":"capability"}],"family_id":"living-people-company-context","jobs":["track-people-and-relationships"],"member_capability_ids":["entity-temperature-engine","relationship-radar"],"outcome":"People and company pages are created, refreshed and connected over time.","title":"Living people and company context"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"commitments","component_type":"capability"},{"capability_id":"delegate-check","component_type":"capability"},{"capability_id":"dex-work-mcp","component_type":"capability"},{"capability_id":"proactive-promise-engine","component_type":"capability"},{"capability_id":"triage","component_type":"capability"}],"family_id":"durable-task-continuity","jobs":["evolve-the-system-itself","keep-projects-on-track","manage-tasks-reliably","track-people-and-relationships"],"member_capability_ids":["commitments","delegate-check","dex-work-mcp","proactive-promise-engine","triage"],"outcome":"Tasks can be captured from several places and completion returns to linked surfaces.","title":"Durable task continuity"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"things-setup","component_type":"capability"},{"capability_id":"todoist-setup","component_type":"capability"},{"capability_id":"trello-setup","component_type":"capability"}],"family_id":"external-task-interoperability","jobs":["manage-tasks-reliably"],"member_capability_ids":["things-setup","todoist-setup","trello-setup"],"outcome":"Todoist, Things and Trello can exchange tasks on request without pretending background polling exists.","title":"External task interoperability"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"apple-mail-setup","component_type":"capability"},{"capability_id":"atlassian-setup","component_type":"capability"},{"capability_id":"calendar-setup","component_type":"capability"},{"capability_id":"dex-calendar-mcp","component_type":"capability"},{"capability_id":"google-workspace-setup","component_type":"capability"},{"capability_id":"ms-teams-setup","component_type":"capability"},{"capability_id":"zoom-setup","component_type":"capability"}],"family_id":"connected-work-context","jobs":["capture-without-friction","keep-projects-on-track","start-each-day-focused","track-people-and-relationships"],"member_capability_ids":["apple-mail-setup","atlassian-setup","calendar-setup","dex-calendar-mcp","google-workspace-setup","ms-teams-setup","zoom-setup"],"outcome":"Google, Teams, Zoom, Atlassian and Apple Mail can inform plans, preparation and reviews when explicitly connected.","title":"Connected work context"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"dex-pipedrive-mcp","component_type":"capability"},{"capability_id":"pipedrive-setup","component_type":"capability"},{"capability_id":"pipeline-sync","component_type":"capability"}],"family_id":"pipedrive-pipeline-continuity","jobs":["keep-projects-on-track","track-people-and-relationships"],"member_capability_ids":["dex-pipedrive-mcp","pipedrive-setup","pipeline-sync"],"outcome":"Live pipeline context informs local work; external writes stay previewed and confirmed.","title":"Pipedrive pipeline continuity"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"daily-plan","component_type":"capability"},{"capability_id":"daily-review","component_type":"capability"},{"capability_id":"week-plan","component_type":"capability"},{"capability_id":"week-review","component_type":"capability"},{"capability_id":"weekly-reflection","component_type":"capability"}],"family_id":"daily-weekly-operating-rhythm","jobs":["reflect-and-improve-continuously","start-each-day-focused"],"member_capability_ids":["daily-plan","daily-review","week-plan","week-review","weekly-reflection"],"outcome":"Planning, review and reflection form one repeatable operating cadence.","title":"Daily and weekly operating rhythm"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"decision-log","component_type":"capability"},{"capability_id":"dex-session-memory","component_type":"capability"},{"capability_id":"enable-semantic-search","component_type":"capability"},{"capability_id":"journal","component_type":"capability"},{"capability_id":"save-insight","component_type":"capability"}],"family_id":"durable-work-memory","jobs":["keep-projects-on-track","reflect-and-improve-continuously"],"member_capability_ids":["decision-log","dex-session-memory","enable-semantic-search","journal","save-insight"],"outcome":"Sourced decisions, commitments, context and patterns remain available across sessions.","title":"Durable work memory"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"dex-doctor","component_type":"capability"},{"capability_id":"dex-smoke-nightly","component_type":"capability"}],"family_id":"proactive-health-and-recovery","jobs":["evolve-the-system-itself"],"member_capability_ids":["dex-doctor","dex-smoke-nightly"],"outcome":"Doctor and scheduled checks distinguish healthy, off, broken and unknown, then use bounded repair paths.","title":"Proactive health and recovery"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"backup-now","component_type":"capability"},{"capability_id":"backup-restore","component_type":"capability"},{"capability_id":"backup-setup","component_type":"capability"},{"capability_id":"dex-vault-backup","component_type":"capability"}],"family_id":"backup-and-restore-confidence","jobs":["evolve-the-system-itself"],"member_capability_ids":["backup-now","backup-restore","backup-setup","dex-vault-backup"],"outcome":"Backups are created and recovery is proved by a safe restore rehearsal.","title":"Backup and restore confidence"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"dex-rollback","component_type":"capability"},{"capability_id":"dex-update","component_type":"capability"},{"capability_id":"diff-adopt","component_type":"capability"},{"capability_id":"diff-adopt-profile","component_type":"capability"},{"capability_id":"diff-generate","component_type":"capability"},{"capability_id":"diff-list","component_type":"capability"},{"capability_id":"diff-profile","component_type":"capability"},{"capability_id":"diff-remove","component_type":"capability"}],"family_id":"safe-change-and-rewind","jobs":["evolve-the-system-itself","reflect-and-improve-continuously"],"member_capability_ids":["dex-rollback","dex-update","diff-adopt","diff-adopt-profile","diff-generate","diff-list","diff-profile","diff-remove"],"outcome":"Changes are previewed, verified, receipted and reversible.","title":"Safe change and rewind"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"create-mcp","component_type":"capability"},{"capability_id":"create-skill","component_type":"capability"},{"capability_id":"dex-add-mcp","component_type":"capability"},{"capability_id":"dex-whats-new","component_type":"capability"},{"capability_id":"integrate-mcp","component_type":"capability"},{"capability_id":"manage-capabilities","component_type":"capability"},{"capability_id":"skill-score","component_type":"capability"}],"family_id":"capability-discovery-and-adoption","jobs":["evolve-the-system-itself"],"member_capability_ids":["create-mcp","create-skill","dex-add-mcp","dex-whats-new","integrate-mcp","manage-capabilities","skill-score"],"outcome":"Useful methods can be discovered, reviewed, adopted and created through the safe lifecycle.","title":"Capability discovery and adoption"},{"aliases":[],"assessment":{"mode":"manual-only","reason":"A person must confirm that no private work leaves the machine before feedback is shared."},"components":[{"capability_id":"feedback","component_type":"capability"}],"family_id":"privacy-safe-feedback-loop","jobs":["evolve-the-system-itself"],"member_capability_ids":["feedback"],"outcome":"A problem can become a minimal report and a returned answer or fix without exporting private work.","title":"Privacy-safe feedback loop"},{"aliases":[],"assessment":{"mode":"automatic","profile":"catalogue"},"components":[{"capability_id":"career-coach","component_type":"capability"},{"capability_id":"career-setup","component_type":"capability"},{"capability_id":"dex-career-mcp","component_type":"capability"},{"capability_id":"dex-resume-mcp","component_type":"capability"},{"capability_id":"resume-builder","component_type":"capability"}],"family_id":"career-growth-evidence","jobs":["reflect-and-improve-continuously","track-career-growth"],"member_capability_ids":["career-coach","career-setup","dex-career-mcp","dex-resume-mcp","resume-builder"],"outcome":"Career and Resume tools turn consented evidence into development and application support without inventing claims.","title":"Career growth evidence"}],"jobs_taxonomy":[{"confirmed_gap_signals":["The Lens session finds a gap related to capture without friction."],"description":"Capture useful ideas, meeting context and incoming information before it disappears or becomes filing work.","job_id":"capture-without-friction","label":"Capture Without Friction"},{"confirmed_gap_signals":["The Lens session finds a gap related to start each day focused."],"description":"Turn current priorities, tasks and calendar pressure into a realistic focus for the day.","job_id":"start-each-day-focused","label":"Start Each Day Focused"},{"confirmed_gap_signals":["The Lens session finds a gap related to track people and relationships."],"description":"Keep the context, commitments and history needed to show up well for important people and organizations.","job_id":"track-people-and-relationships","label":"Track People & Relationships"},{"confirmed_gap_signals":["The Lens session finds a gap related to manage tasks reliably."],"description":"Keep tasks, promises and delegated work from scattering or quietly going unmet.","job_id":"manage-tasks-reliably","label":"Manage Tasks Reliably"},{"confirmed_gap_signals":["The Lens session finds a gap related to reflect and improve continuously."],"description":"Turn reflection, decisions and observed friction into durable learning and better ways of working.","job_id":"reflect-and-improve-continuously","label":"Reflect & Improve Continuously"},{"confirmed_gap_signals":["The Lens session finds a gap related to keep projects on track."],"description":"Maintain enough project truth, decisions and next actions to keep important work moving.","job_id":"keep-projects-on-track","label":"Keep Projects On Track"},{"confirmed_gap_signals":["The Lens session finds a gap related to track career growth."],"description":"Use consented evidence and reflection to support truthful career development and application material.","job_id":"track-career-growth","label":"Track Career Growth"},{"confirmed_gap_signals":["The Lens session finds a gap related to evolve the system itself."],"description":"Inspect, extend, update and recover the system without sacrificing human control or portability.","job_id":"evolve-the-system-itself","label":"Evolve the System Itself"}],"portable_brief":{"audience":"the person's own AI system","format":"markdown","safety_boundary":"Brief only: Lens presents adaptation guidance and never applies Dex changes automatically."}},"metadata":{"catalog_version":7,"contract_version":"dex-lens-catalogue-v2","core_release":"v0.0.0-preview","expires_at":"2026-09-24T12:00:00Z","key_id":"dex-core-lens-1","produced_at":"2026-08-25T12:00:00Z","producer":"Dex Core enriched preview (version-independent example)"},"signature":"UNSIGNED-PREVIEW-NOT-FOR-PUBLICATION"} From b0dcc3a39a5f9dc73d76377aba209dee75333569 Mon Sep 17 00:00:00 2001 From: Chris Jackson <201591867+chrisjackson-coding@users.noreply.github.com> Date: Tue, 25 Aug 2026 10:41:14 +0100 Subject: [PATCH 4/7] Have skills call the adoption tool instead of hand-editing the log Follow-up to the parent commit, which made mark_feature_used work and made it reachable. Nothing called it, so the log still depended on the assistant remembering to edit markdown mid-task, which is the failure that started this. Replaces "Update System/usage_log.md to mark X as used" with a call to the tool in the 22 skills whose slash command resolves to exactly one line in the shipped log. Four skills are deliberately left on prose: commitments, initiative-kickoff, meeting-closeout and relationship-radar have no line in the log at all, so wiring them would produce a not_found and record nothing. Adding entries for them is a content change to the log itself and belongs in its own PR. /journal is named by its label rather than its command, because /journal appears against both Journaling and Journaling setup and the tool refuses to guess. The instruction says why, so it does not get "tidied" back. The test parameterises over every wired skill and resolves its feature name against the shipped log with the real matcher, so an instruction can never drift into naming something that does not exist. It caught a nested-backtick bug in the journal instruction while this was being written, which is precisely the class of silent no-op it exists to prevent. Co-authored-by: davekilleen --- .claude/skills/create-mcp/SKILL.md | 2 +- .claude/skills/create-skill/SKILL.md | 2 +- .claude/skills/daily-plan/SKILL.md | 2 +- .claude/skills/daily-review/SKILL.md | 2 +- .claude/skills/dex-add-mcp/SKILL.md | 2 +- .claude/skills/dex-backlog/SKILL.md | 2 +- .claude/skills/dex-improve/SKILL.md | 2 +- .claude/skills/dex-obsidian-setup/SKILL.md | 2 +- .claude/skills/dex-whats-new/SKILL.md | 2 +- .claude/skills/getting-started/SKILL.md | 2 +- .claude/skills/integrate-mcp/SKILL.md | 2 +- .claude/skills/journal/SKILL.md | 2 +- .claude/skills/meeting-prep/SKILL.md | 2 +- .claude/skills/process-meetings/SKILL.md | 2 +- .claude/skills/product-brief/SKILL.md | 2 +- .claude/skills/project-health/SKILL.md | 2 +- .claude/skills/prompt-improver/SKILL.md | 2 +- .claude/skills/reset/SKILL.md | 2 +- .claude/skills/save-insight/SKILL.md | 2 +- .claude/skills/triage/SKILL.md | 2 +- .claude/skills/week-review/SKILL.md | 2 +- .claude/skills/xray/SKILL.md | 2 +- core/tests/test_usage_tracking.py | 147 +++++++++++++++++++++ 23 files changed, 169 insertions(+), 22 deletions(-) diff --git a/.claude/skills/create-mcp/SKILL.md b/.claude/skills/create-mcp/SKILL.md index 5e7911032..ccdc7d735 100644 --- a/.claude/skills/create-mcp/SKILL.md +++ b/.claude/skills/create-mcp/SKILL.md @@ -730,7 +730,7 @@ See `.claude/reference/skill-analytics-checklist.md` for detailed guidance. ## Track Usage (Silent) -Update `System/usage_log.md` to mark MCP creation as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `create-mcp`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/create-skill/SKILL.md b/.claude/skills/create-skill/SKILL.md index 48b7099be..8ea521e3f 100644 --- a/.claude/skills/create-skill/SKILL.md +++ b/.claude/skills/create-skill/SKILL.md @@ -130,6 +130,6 @@ A good run leaves behind a skill that **fires on the user's real phrasing, route ## Track Usage (Silent) -Update `System/usage_log.md` to mark custom skill creation as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `create-skill`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** Call `track_event` with event_name `custom_skill_created` and no properties (never include skill names). Fires only if the user opted into analytics; no action if it returns "analytics_disabled". diff --git a/.claude/skills/daily-plan/SKILL.md b/.claude/skills/daily-plan/SKILL.md index 8f0cbd2d5..8296725c1 100644 --- a/.claude/skills/daily-plan/SKILL.md +++ b/.claude/skills/daily-plan/SKILL.md @@ -753,7 +753,7 @@ After generating the plan, push today's P0 and P1 focus tasks to Apple Reminders ## Step 8: Track Usage (Silent) -Update `System/usage_log.md` to mark daily planning as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `daily-plan`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/daily-review/SKILL.md b/.claude/skills/daily-review/SKILL.md index c5259c9d1..d8fd0142e 100644 --- a/.claude/skills/daily-review/SKILL.md +++ b/.claude/skills/daily-review/SKILL.md @@ -394,7 +394,7 @@ At the end of the review, check if there's a relevant backlog idea to surface: ## Step 10: Track Usage (Silent) -Update `System/usage_log.md` to mark daily review as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `daily-review`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/dex-add-mcp/SKILL.md b/.claude/skills/dex-add-mcp/SKILL.md index a259a941d..ad155facb 100644 --- a/.claude/skills/dex-add-mcp/SKILL.md +++ b/.claude/skills/dex-add-mcp/SKILL.md @@ -63,7 +63,7 @@ claude mcp add --scope project github --transport http https://api.githubcopilot ## Track Usage (Silent) -Update `System/usage_log.md` to mark MCP addition as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `dex-add-mcp`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/dex-backlog/SKILL.md b/.claude/skills/dex-backlog/SKILL.md index e3c5d2c0b..66b437ec0 100644 --- a/.claude/skills/dex-backlog/SKILL.md +++ b/.claude/skills/dex-backlog/SKILL.md @@ -635,7 +635,7 @@ But you're still the decision maker. If a low-scoring idea excites you, workshop ## Track Usage (Silent) -Update `System/usage_log.md` to mark backlog review as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `dex-backlog`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/dex-improve/SKILL.md b/.claude/skills/dex-improve/SKILL.md index 1153a4732..91ddb5860 100644 --- a/.claude/skills/dex-improve/SKILL.md +++ b/.claude/skills/dex-improve/SKILL.md @@ -409,7 +409,7 @@ This isn't just requirements gathering—it's capability-aware design. The goal ## Track Usage (Silent) -Update `System/usage_log.md` to mark improvement workshop as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `dex-improve`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/dex-obsidian-setup/SKILL.md b/.claude/skills/dex-obsidian-setup/SKILL.md index ed63f4219..6a195ba15 100644 --- a/.claude/skills/dex-obsidian-setup/SKILL.md +++ b/.claude/skills/dex-obsidian-setup/SKILL.md @@ -140,7 +140,7 @@ You can still use Dex in Cursor/terminal exactly as before. Wiki links work ever ## Track Usage (Silent) -Update `System/usage_log.md` to mark Obsidian setup as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `dex-obsidian-setup`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/dex-whats-new/SKILL.md b/.claude/skills/dex-whats-new/SKILL.md index ad7e5a3c5..6452b9627 100644 --- a/.claude/skills/dex-whats-new/SKILL.md +++ b/.claude/skills/dex-whats-new/SKILL.md @@ -417,7 +417,7 @@ Then proceed with first-run behavior. ## Track Usage (Silent) -Update `System/usage_log.md` to mark what's new check as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `dex-whats-new`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/getting-started/SKILL.md b/.claude/skills/getting-started/SKILL.md index c97bae495..97529674c 100644 --- a/.claude/skills/getting-started/SKILL.md +++ b/.claude/skills/getting-started/SKILL.md @@ -947,7 +947,7 @@ else: ## Track Usage (Silent) -Update `System/usage_log.md` to mark getting started as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `getting-started`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/integrate-mcp/SKILL.md b/.claude/skills/integrate-mcp/SKILL.md index bb1c664c7..453774a06 100644 --- a/.claude/skills/integrate-mcp/SKILL.md +++ b/.claude/skills/integrate-mcp/SKILL.md @@ -377,7 +377,7 @@ The experience feels like: ## Track Usage (Silent) -Update `System/usage_log.md` to mark MCP integration as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `integrate-mcp`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/journal/SKILL.md b/.claude/skills/journal/SKILL.md index a772cd418..67c2528d1 100644 --- a/.claude/skills/journal/SKILL.md +++ b/.claude/skills/journal/SKILL.md @@ -173,7 +173,7 @@ Perfect. Your morning journal is saved. Ready to build your daily plan around th ## Track Usage (Silent) -Update `System/usage_log.md` to mark journaling as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `Journaling`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. (Named by label rather than by `/journal`, because that command appears against both `Journaling` and `Journaling setup` and the tool refuses to guess between them.) **Analytics (Silent):** diff --git a/.claude/skills/meeting-prep/SKILL.md b/.claude/skills/meeting-prep/SKILL.md index 290212924..8489185c1 100644 --- a/.claude/skills/meeting-prep/SKILL.md +++ b/.claude/skills/meeting-prep/SKILL.md @@ -458,7 +458,7 @@ After the meeting: ## Track Usage (Silent) -Update `System/usage_log.md` to mark meeting prep as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `meeting-prep`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/process-meetings/SKILL.md b/.claude/skills/process-meetings/SKILL.md index 1798c3caa..c4983d4a1 100644 --- a/.claude/skills/process-meetings/SKILL.md +++ b/.claude/skills/process-meetings/SKILL.md @@ -532,7 +532,7 @@ For MCP responses, follow CLAUDE.md's `feature_status` rendering convention befo ## Track Usage (Silent) -Update `System/usage_log.md` to mark meeting processing as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `process-meetings`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/product-brief/SKILL.md b/.claude/skills/product-brief/SKILL.md index e52072fbb..e2d739f95 100644 --- a/.claude/skills/product-brief/SKILL.md +++ b/.claude/skills/product-brief/SKILL.md @@ -805,7 +805,7 @@ If any are missing, prompt user to fill gaps before finalizing. ## Track Usage (Silent) -Update `System/usage_log.md` to mark product brief as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `product-brief`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/project-health/SKILL.md b/.claude/skills/project-health/SKILL.md index a7bde15bd..cffc4b4a4 100644 --- a/.claude/skills/project-health/SKILL.md +++ b/.claude/skills/project-health/SKILL.md @@ -85,7 +85,7 @@ For red projects: ## Track Usage (Silent) -Update `System/usage_log.md` to mark project health check as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `project-health`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/prompt-improver/SKILL.md b/.claude/skills/prompt-improver/SKILL.md index 2dce659ee..eda6b0e2a 100644 --- a/.claude/skills/prompt-improver/SKILL.md +++ b/.claude/skills/prompt-improver/SKILL.md @@ -226,7 +226,7 @@ Without the API key, the skill still works using the current LLM session. ## Track Usage (Silent) -Update `System/usage_log.md` to mark prompt improvement as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `prompt-improver`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/reset/SKILL.md b/.claude/skills/reset/SKILL.md index 0be880cd0..813ba4748 100644 --- a/.claude/skills/reset/SKILL.md +++ b/.claude/skills/reset/SKILL.md @@ -97,7 +97,7 @@ profile writes and their validation. ## Track Usage (Silent) -Update `System/usage_log.md` to mark vault reset as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `reset`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/save-insight/SKILL.md b/.claude/skills/save-insight/SKILL.md index 78672d7af..1842cd66d 100644 --- a/.claude/skills/save-insight/SKILL.md +++ b/.claude/skills/save-insight/SKILL.md @@ -88,7 +88,7 @@ Be specific. Include the gotcha. Make it searchable. ## Track Usage (Silent) -Update `System/usage_log.md` to mark learning capture as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `save-insight`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/triage/SKILL.md b/.claude/skills/triage/SKILL.md index 9593a3906..6d5914d8d 100644 --- a/.claude/skills/triage/SKILL.md +++ b/.claude/skills/triage/SKILL.md @@ -400,7 +400,7 @@ No configuration needed - triage adapts as your structure grows. ## Track Usage (Silent) -Update `System/usage_log.md` to mark inbox triage as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `triage`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/week-review/SKILL.md b/.claude/skills/week-review/SKILL.md index 2188d89f7..f49b6c33b 100644 --- a/.claude/skills/week-review/SKILL.md +++ b/.claude/skills/week-review/SKILL.md @@ -568,7 +568,7 @@ After synthesis: ## Track Usage (Silent) -Update `System/usage_log.md` to mark weekly review as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `week-review`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.claude/skills/xray/SKILL.md b/.claude/skills/xray/SKILL.md index 82b2c4ce0..e63306141 100644 --- a/.claude/skills/xray/SKILL.md +++ b/.claude/skills/xray/SKILL.md @@ -788,7 +788,7 @@ If user runs specific educational modes, update the AI Education Progress sectio ## Track Usage (Silent) -Update `System/usage_log.md` to mark AI transparency education as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `xray`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/core/tests/test_usage_tracking.py b/core/tests/test_usage_tracking.py index f21f5821e..fa4e3258b 100644 --- a/core/tests/test_usage_tracking.py +++ b/core/tests/test_usage_tracking.py @@ -8,6 +8,8 @@ from __future__ import annotations +import json +import re from pathlib import Path import pytest @@ -350,3 +352,148 @@ def test_the_operation_may_write_only_the_usage_log() -> None: assert allowed.action == "write-usage-log" assert refused.allowed is False assert refused.action == "outside-usage-log" + + +# --- the wiring itself, pinned to an explicit expected set --- +# +# Requested in review of #593. A "at least N are wired" check cannot catch a +# specific omission: week-plan was missed and the suite stayed green. The set +# below is the contract. Adding a skill to the log without wiring it, or +# unwiring one, now fails here by name. + +_REPO_ROOT = Path(__file__).resolve().parents[2] +_SKILLS_DIR = _REPO_ROOT / ".claude" / "skills" +_INSTRUCTION = re.compile( + r"Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `([^`]+)`" +) + +# skill directory -> the feature argument its instruction passes. +EXPECTED_WIRING = { + "create-mcp": "create-mcp", + "create-skill": "create-skill", + "daily-plan": "daily-plan", + "daily-review": "daily-review", + "dex-add-mcp": "dex-add-mcp", + "dex-backlog": "dex-backlog", + "dex-improve": "dex-improve", + "dex-level-up": "dex-level-up", + "dex-obsidian-setup": "dex-obsidian-setup", + "dex-whats-new": "dex-whats-new", + "getting-started": "getting-started", + "integrate-mcp": "integrate-mcp", + # /journal appears against two lines, so this one names the label. + "journal": "Journaling", + "meeting-prep": "meeting-prep", + "process-meetings": "process-meetings", + "product-brief": "product-brief", + "project-health": "project-health", + "prompt-improver": "prompt-improver", + "reset": "reset", + "save-insight": "save-insight", + "triage": "triage", + "week-plan": "week-plan", + "week-review": "week-review", + "xray": "xray", +} + +# Skills left on prose ON PURPOSE, each with the reason. A skill leaves this +# map only by being wired, and a new checkbox in the shipped log makes the +# reason false, which the next test detects. +DEFERRED_WIRING = { + "commitments": "no line in the shipped usage log", + "dex-doctor": "no line in the shipped usage log", + "initiative-kickoff": "no line in the shipped usage log", + "meeting-closeout": "no line in the shipped usage log", + "relationship-radar": "no line in the shipped usage log", +} + + +def _actual_wiring() -> dict[str, str]: + found = {} + for skill in sorted(_SKILLS_DIR.glob("*/SKILL.md")): + match = _INSTRUCTION.search(skill.read_text(encoding="utf-8")) + if match: + found[skill.parent.name] = match.group(1) + return found + + +def test_exactly_the_expected_skills_are_wired() -> None: + actual = _actual_wiring() + + assert actual == EXPECTED_WIRING, ( + "wiring drifted. Missing: " + f"{sorted(set(EXPECTED_WIRING) - set(actual))}; " + f"unexpected: {sorted(set(actual) - set(EXPECTED_WIRING))}; " + "changed arguments: " + f"{ {k: (EXPECTED_WIRING[k], actual[k]) for k in set(actual) & set(EXPECTED_WIRING) if actual[k] != EXPECTED_WIRING[k]} }" + ) + + +def test_every_deferred_skill_still_has_a_true_reason() -> None: + """A deferred skill that gains a log line must stop being deferred.""" + log = (_REPO_ROOT / "System" / "usage_log.md").read_text(encoding="utf-8") + lines = log.splitlines(keepends=True) + + now_wireable = [ + name + for name, reason in DEFERRED_WIRING.items() + if reason == "no line in the shipped usage log" + and len(analytics_helper._match_feature_lines(lines, name)) == 1 + ] + + assert not now_wireable, ( + f"{now_wireable} are deferred for having no line in the log, but the log now " + "resolves them. Wire them or change the recorded reason." + ) + + +def test_no_skill_mentions_the_tool_in_a_shape_this_check_cannot_read() -> None: + """A skill the detector cannot parse is a skill nobody is validating. + + An earlier fix wrote dex-level-up's instruction in a different shape; it + escaped the detector and the suite stayed green while nothing checked it. + """ + readable = set(_actual_wiring()) + unreadable = [ + skill.parent.name + for skill in sorted(_SKILLS_DIR.glob("*/SKILL.md")) + if "mark_feature_used" in skill.read_text(encoding="utf-8") + and skill.parent.name not in readable + ] + + assert not unreadable, ( + f"{unreadable} reference mark_feature_used in a shape this test cannot read, " + "so the feature name they pass is unvalidated." + ) + + +@pytest.mark.parametrize("skill,feature", sorted(EXPECTED_WIRING.items())) +def test_each_wired_skill_resolves_through_the_real_tool( + skill: str, feature: str, tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + """Exercise the shipped log through the MCP tool, not just the matcher. + + Requested in review: the check should run at the actual tool boundary, so + a skill's instruction is proven to move a box in the real shipped file. + """ + import asyncio + + from core.mcp import analytics_server + + vault = tmp_path / skill + (vault / "System").mkdir(parents=True) + shipped = (_REPO_ROOT / "System" / "usage_log.md").read_text(encoding="utf-8") + log = vault / "System" / "usage_log.md" + log.write_text(shipped, encoding="utf-8") + monkeypatch.setenv("VAULT_PATH", str(vault)) + + payload = json.loads( + asyncio.run( + analytics_server.call_tool("mark_feature_used", {"feature": feature}) + )[0].text + ) + + assert payload["status"] in {"marked", "already_marked"}, ( + f"{skill} passes {feature!r}, which the shipped log answers with " + f"{payload['status']!r}. Its instruction records nothing." + ) From cba1c86a2567ffa99485c7fd69db757610450940 Mon Sep 17 00:00:00 2001 From: Chris Jackson <201591867+chrisjackson-coding@users.noreply.github.com> Date: Tue, 25 Aug 2026 19:32:40 +0100 Subject: [PATCH 5/7] Wire the two skills the first pass silently skipped The wiring script matched on the phrase 'to mark X as used' and reported 'wired 22 skills' as though that were complete. Three skills phrase it differently and were excluded before the checkbox test ever ran. Two of them have a box in the shipped log and should have been wired: - week-plan, which says only 'Update System/usage_log.md.' - dex-level-up, whose Step 6 is the more consequential of the two: it marks OTHER features as the user tries them, and it is the skill that reads this log to decide what to recommend next. It was hand-editing the file it depends on. dex-doctor stays on prose: it has no line in the shipped log, like the four already recorded as unwireable. dex-level-up now uses the tool for both jobs, records its own use, and is told to check the returned status, because not_found and ambiguous pass silently and this skill is the one that suffers. Also closes the hole in the test that allowed this. Its detector reads one canonical phrasing, so a skill referencing the tool any other way was skipped without failing. dex-level-up did exactly that on the first attempt at this fix. The suite now fails on any skill that mentions mark_feature_used in a shape it cannot parse, with parameterised callers listed explicitly rather than matched by accident. 42 tests pass. Lens registry and architecture inventory regenerated. Co-authored-by: davekilleen --- .claude/skills/dex-level-up/SKILL.md | 16 ++++++++++++++-- .claude/skills/week-plan/SKILL.md | 2 +- core/lens-catalog/registry.json | 8 ++++---- 3 files changed, 19 insertions(+), 7 deletions(-) diff --git a/.claude/skills/dex-level-up/SKILL.md b/.claude/skills/dex-level-up/SKILL.md index 0a441cb9c..7f2ed6e8c 100644 --- a/.claude/skills/dex-level-up/SKILL.md +++ b/.claude/skills/dex-level-up/SKILL.md @@ -278,7 +278,17 @@ Just say the number or feature name, and I'll guide you through it. ## Step 6: Track Adoption (Silent) -When user tries a recommended feature, silently update `System/usage_log.md` by checking the box for that feature. +When the user tries a recommended feature, record it by calling the `mark_feature_used` tool on +the `dex-analytics` MCP server with **that feature's** slash command (not this skill's). The tool +ticks the box, refuses to guess when a name is ambiguous, and returns a status: `marked`, +`already_marked`, `ambiguous`, `not_found` or `unavailable`. + +**Check the status.** `not_found` means the feature has no line in the log and nothing was +recorded; `ambiguous` means several lines matched and it declined to choose. Both pass silently +if nobody looks, and this skill is the one that suffers, because it reads this log to decide what +to recommend next. + +**Also record this skill's own use.** Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `dex-level-up`. **Update triggers:** - User runs a command → Check command box @@ -289,7 +299,9 @@ When user tries a recommended feature, silently update `System/usage_log.md` by - **User runs role-specific skill** → Check "Used" box in Role-Specific Skills section **Update method:** -- Simple find/replace: `- [ ] Feature` → `- [x] Feature` +- The `mark_feature_used` tool, once per feature. Do not hand-edit the file: the write goes + through a guarded lifecycle operation that validates the path, preserves the file mode and + stops a concurrent consent update losing this change. - No announcement needed **Role-Specific Skills Tracking:** diff --git a/.claude/skills/week-plan/SKILL.md b/.claude/skills/week-plan/SKILL.md index 517e983c7..480580d67 100644 --- a/.claude/skills/week-plan/SKILL.md +++ b/.claude/skills/week-plan/SKILL.md @@ -419,7 +419,7 @@ Create updated `02-Week_Priorities/Week_Priorities.md`: ## Step 7: Track Usage (Silent) -Update `System/usage_log.md`. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `week-plan`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/core/lens-catalog/registry.json b/core/lens-catalog/registry.json index a9c8a6c48..25c6159bd 100644 --- a/core/lens-catalog/registry.json +++ b/core/lens-catalog/registry.json @@ -122,8 +122,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/week-plan/SKILL.md", - "sha256": "9f98cdfcacfea8d79d1ed437e21b173fdae37329dce1fbcaf377c17f470e3e23", - "byte_size": 16511 + "sha256": "89018c83c114c1a16dd4da8021216b41c93d20c8ea2a351a69ab1a0e2c90f9eb", + "byte_size": 16791 }, "value": "Turns goals, capacity and open work into a weekly focus plan, so repeated work starts from priorities rather than a blank chat.", "jobs_served": [ @@ -4692,8 +4692,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/dex-level-up/SKILL.md", - "sha256": "7802c1abbe4d394cecfbb9782252b7725cff402ee804165b994c86c5327997e0", - "byte_size": 18888 + "sha256": "1c8d0102e351c7ddc26eef8335aa68dd0bec88d8097cb3deff83304b72dff0ec", + "byte_size": 19733 }, "value": "Surface Dex features the user isn't using yet, based on their usage patterns.", "jobs_served": [ From 8975ee9cdd1a01914f2ea88b1077884516f5d80f Mon Sep 17 00:00:00 2001 From: Chris Jackson <201591867+chrisjackson-coding@users.noreply.github.com> Date: Wed, 26 Aug 2026 10:10:01 +0100 Subject: [PATCH 6/7] Record the journal mode that actually ran The journal skill runs setup and entry modes, and the usage log carries a separate line for each. One unconditional call to mark "Journaling" meant "Journaling setup" could never be ticked by the only command that performs it, so /dex-level-up would keep recommending setup to people who had already done it. /journal on and /journal off now record "Journaling setup"; the entry modes record "Journaling". Both still name the label rather than /journal, which matches both lines and returns ambiguous. The test grew with it. Expected wiring now holds every feature a skill records, not one, so a dropped mode fails exact equality. Six explicit scenarios tie each documented mode to the line it must tick, and a further case asserts /journal is still ambiguous, so if that ever stops being true the skill's stated reason for using labels cannot quietly go stale. Reintroducing the single unconditional call fails seven of these by name. Co-Authored-By: Claude Opus 5 --- .claude/skills/journal/SKILL.md | 20 ++++- core/tests/test_usage_tracking.py | 138 ++++++++++++++++++++++++++++-- 2 files changed, 148 insertions(+), 10 deletions(-) diff --git a/.claude/skills/journal/SKILL.md b/.claude/skills/journal/SKILL.md index 67c2528d1..d1add0e31 100644 --- a/.claude/skills/journal/SKILL.md +++ b/.claude/skills/journal/SKILL.md @@ -173,7 +173,25 @@ Perfect. Your morning journal is saved. Ready to build your daily plan around th ## Track Usage (Silent) -Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `Journaling`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. (Named by label rather than by `/journal`, because that command appears against both `Journaling` and `Journaling setup` and the tool refuses to guess between them.) +This skill has two distinct modes and the usage log has a separate line for each, so +**which one you record depends on the mode you just ran**: + +| Mode | Record | +|------|--------| +| `/journal on`, `/journal off` | Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `Journaling setup` | +| `/journal`, `/journal morning`, `/journal evening`, `/journal week` | Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `Journaling` | + +Record exactly one, for the mode that actually ran. Turning journaling on is not the same as +writing an entry, and a single unconditional call would mean `Journaling setup` could never +be ticked by the only command that performs it. + +Both are named by **label** rather than by `/journal`, because that command appears against +both lines and the tool refuses to guess between them; passing `/journal` returns `ambiguous` +and records nothing. + +This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to +recommend features that have not been tried. It writes locally and sends nothing, so it runs +whether or not analytics is enabled. **Analytics (Silent):** diff --git a/core/tests/test_usage_tracking.py b/core/tests/test_usage_tracking.py index fa4e3258b..c03b4dcbe 100644 --- a/core/tests/test_usage_tracking.py +++ b/core/tests/test_usage_tracking.py @@ -367,7 +367,10 @@ def test_the_operation_may_write_only_the_usage_log() -> None: r"Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `([^`]+)`" ) -# skill directory -> the feature argument its instruction passes. +# skill directory -> EVERY feature argument its instruction passes. Almost all +# skills record one thing. A skill with distinct modes records the mode that +# ran, so its entry lists each one and the exact-equality check below fails if +# a mode is dropped or silently collapsed into a single unconditional call. EXPECTED_WIRING = { "create-mcp": "create-mcp", "create-skill": "create-skill", @@ -381,8 +384,10 @@ def test_the_operation_may_write_only_the_usage_log() -> None: "dex-whats-new": "dex-whats-new", "getting-started": "getting-started", "integrate-mcp": "integrate-mcp", - # /journal appears against two lines, so this one names the label. - "journal": "Journaling", + # Two modes, two lines in the log. Setup can only ever be ticked by the + # command that performs it, so the call has to follow the mode. Named by + # label because /journal itself is ambiguous across both lines. + "journal": ("Journaling setup", "Journaling"), "meeting-prep": "meeting-prep", "process-meetings": "process-meetings", "product-brief": "product-brief", @@ -408,15 +413,27 @@ def test_the_operation_may_write_only_the_usage_log() -> None: } -def _actual_wiring() -> dict[str, str]: - found = {} +def _actual_wiring() -> dict[str, object]: + """Every feature each skill records, in the order its instruction states them. + + Returns a bare string for the single-call majority and a tuple for a skill + with distinct modes, matching the shape of EXPECTED_WIRING above. + """ + found: dict[str, object] = {} for skill in sorted(_SKILLS_DIR.glob("*/SKILL.md")): - match = _INSTRUCTION.search(skill.read_text(encoding="utf-8")) - if match: - found[skill.parent.name] = match.group(1) + names = _INSTRUCTION.findall(skill.read_text(encoding="utf-8")) + # Preserve order, drop repeats: a skill may restate the same call in + # prose without that being a second, distinct thing it records. + unique = list(dict.fromkeys(names)) + if unique: + found[skill.parent.name] = unique[0] if len(unique) == 1 else tuple(unique) return found +def _features_of(entry: object) -> tuple[str, ...]: + return (entry,) if isinstance(entry, str) else tuple(entry) + + def test_exactly_the_expected_skills_are_wired() -> None: actual = _actual_wiring() @@ -467,7 +484,14 @@ def test_no_skill_mentions_the_tool_in_a_shape_this_check_cannot_read() -> None: ) -@pytest.mark.parametrize("skill,feature", sorted(EXPECTED_WIRING.items())) +@pytest.mark.parametrize( + "skill,feature", + sorted( + (skill, feature) + for skill, entry in EXPECTED_WIRING.items() + for feature in _features_of(entry) + ), +) def test_each_wired_skill_resolves_through_the_real_tool( skill: str, feature: str, tmp_path: Path, monkeypatch: pytest.MonkeyPatch ) -> None: @@ -497,3 +521,99 @@ def test_each_wired_skill_resolves_through_the_real_tool( f"{skill} passes {feature!r}, which the shipped log answers with " f"{payload['status']!r}. Its instruction records nothing." ) + + +# --- mode-specific scenarios --- +# +# Raised in review of #593: the journal skill runs setup and entry modes, and +# the log carries a separate line for each, so one unconditional call means +# "Journaling setup" can never be ticked by the only command that performs it. +# A count-based or one-call-per-skill check cannot see that, so the scenarios +# are written out. + +# (skill, the invocation, the log line it must tick) +MODE_SCENARIOS = [ + ("journal", "/journal on", "Journaling setup"), + ("journal", "/journal off", "Journaling setup"), + ("journal", "/journal", "Journaling"), + ("journal", "/journal morning", "Journaling"), + ("journal", "/journal evening", "Journaling"), + ("journal", "/journal week", "Journaling"), +] + + +@pytest.mark.parametrize("skill,invocation,feature", MODE_SCENARIOS) +def test_each_mode_names_the_line_it_should_tick( + skill: str, invocation: str, feature: str +) -> None: + body = (_SKILLS_DIR / skill / "SKILL.md").read_text(encoding="utf-8") + + # Backticked throughout, which also keeps "/journal" from matching the + # "/journal on" row as a substring and testing the wrong mode. + quoted = f"`{invocation}`" + assert quoted in body, f"{skill} no longer documents {invocation}; retire this case" + assert feature in _features_of(EXPECTED_WIRING[skill]), ( + f"{skill} does not record {feature!r} at all, so {invocation} cannot tick it." + ) + + # The mode and the feature it records have to appear together, otherwise + # the skill states two calls and leaves the reader to guess which mode + # takes which, which is the ambiguity this test exists to prevent. + row = next( + (line for line in body.splitlines() if quoted in line and "mark_feature_used" in line), + None, + ) + assert row is not None, ( + f"{skill} records {feature!r} somewhere, but nothing ties {invocation} to a call. " + "State the mode and its feature on the same line." + ) + assert f"`{feature}`" in row, ( + f"{invocation} is tied to a call that does not pass {feature!r}: {row.strip()!r}" + ) + + +def test_a_skill_with_several_modes_never_records_them_unconditionally() -> None: + """One call for a multi-line skill silently starves the other line. + + The failure is invisible in the output: the call succeeds, a box ticks, + and the line that should have ticked stays empty forever. + """ + multi = {skill for skill, _, _ in MODE_SCENARIOS} + for skill in sorted(multi): + features = _features_of(EXPECTED_WIRING[skill]) + expected = {feature for s, _, feature in MODE_SCENARIOS if s == skill} + assert set(features) == expected, ( + f"{skill} records {sorted(features)} but its modes cover {sorted(expected)}. " + "Every documented mode needs the line it ticks, and no others." + ) + + +def test_the_ambiguous_command_is_still_ambiguous( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + """Why journal is wired by label: /journal matches both of its lines. + + If the log ever stops being ambiguous for /journal, the label indirection + is no longer needed and the skill's explanation for it becomes untrue. + """ + import asyncio + + from core.mcp import analytics_server + + vault = tmp_path / "ambiguous" + (vault / "System").mkdir(parents=True) + (vault / "System" / "usage_log.md").write_text( + (_REPO_ROOT / "System" / "usage_log.md").read_text(encoding="utf-8"), encoding="utf-8" + ) + monkeypatch.setenv("VAULT_PATH", str(vault)) + + payload = json.loads( + asyncio.run( + analytics_server.call_tool("mark_feature_used", {"feature": "/journal"}) + )[0].text + ) + + assert payload["status"] == "ambiguous", ( + "/journal now resolves to a single line, so the journal skill's stated reason for " + f"naming its features by label is stale: {payload}" + ) From 87900bdfec0751fac4c5198c31cb55ab05255d76 Mon Sep 17 00:00:00 2001 From: Chris Jackson <201591867+chrisjackson-coding@users.noreply.github.com> Date: Wed, 26 Aug 2026 10:31:20 +0100 Subject: [PATCH 7/7] Repin the catalogue to the edited skill files Thirteen of the skills wired here are Lens capabilities, and the registry pins each one's exact bytes. Editing them left the pins stale, so the release generation refuses. Repinned from the files themselves, then verified every active-skill entry in the registry against its file rather than trusting the edit: zero inconsistent. Co-Authored-By: Claude Opus 5 Co-authored-by: davekilleen --- .agents/skills/create-mcp/SKILL.md | 2 +- .agents/skills/daily-plan/SKILL.md | 2 +- .agents/skills/daily-review/SKILL.md | 2 +- .agents/skills/dex-backlog/SKILL.md | 2 +- .agents/skills/dex-improve/SKILL.md | 2 +- .agents/skills/dex-obsidian-setup/SKILL.md | 2 +- .agents/skills/dex-whats-new/SKILL.md | 2 +- .agents/skills/getting-started/SKILL.md | 2 +- .agents/skills/integrate-mcp/SKILL.md | 2 +- .agents/skills/journal/SKILL.md | 20 ++- .agents/skills/meeting-prep/SKILL.md | 2 +- .agents/skills/process-meetings/SKILL.md | 2 +- .agents/skills/product-brief/SKILL.md | 2 +- .agents/skills/project-health/SKILL.md | 2 +- .agents/skills/prompt-improver/SKILL.md | 2 +- .agents/skills/save-insight/SKILL.md | 2 +- .agents/skills/triage/SKILL.md | 2 +- .agents/skills/week-plan/SKILL.md | 2 +- .agents/skills/week-review/SKILL.md | 2 +- core/lens-catalog/registry.json | 124 +++++++++--------- docs/architecture/INVENTORY.md | 4 +- .../skills/create-mcp/SKILL.md | 2 +- .../skills/daily-plan/SKILL.md | 2 +- .../skills/daily-review/SKILL.md | 2 +- .../skills/dex-backlog/SKILL.md | 2 +- .../skills/dex-improve/SKILL.md | 2 +- .../skills/dex-obsidian-setup/SKILL.md | 2 +- .../skills/dex-whats-new/SKILL.md | 2 +- .../skills/getting-started/SKILL.md | 2 +- .../skills/integrate-mcp/SKILL.md | 2 +- .../dex-agent-plugin/skills/journal/SKILL.md | 20 ++- .../skills/meeting-prep/SKILL.md | 2 +- .../skills/process-meetings/SKILL.md | 2 +- .../skills/product-brief/SKILL.md | 2 +- .../skills/project-health/SKILL.md | 2 +- .../skills/prompt-improver/SKILL.md | 2 +- .../skills/save-insight/SKILL.md | 2 +- .../dex-agent-plugin/skills/triage/SKILL.md | 2 +- .../skills/week-plan/SKILL.md | 2 +- .../skills/week-review/SKILL.md | 2 +- 40 files changed, 138 insertions(+), 102 deletions(-) diff --git a/.agents/skills/create-mcp/SKILL.md b/.agents/skills/create-mcp/SKILL.md index 218f00565..ce792eaae 100644 --- a/.agents/skills/create-mcp/SKILL.md +++ b/.agents/skills/create-mcp/SKILL.md @@ -732,7 +732,7 @@ See `.claude/reference/skill-analytics-checklist.md` for detailed guidance. ## Track Usage (Silent) -Update `System/usage_log.md` to mark MCP creation as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `create-mcp`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/daily-plan/SKILL.md b/.agents/skills/daily-plan/SKILL.md index 2f70255ba..e2fc085d4 100644 --- a/.agents/skills/daily-plan/SKILL.md +++ b/.agents/skills/daily-plan/SKILL.md @@ -744,7 +744,7 @@ After generating the plan, push today's P0 and P1 focus tasks to Apple Reminders ## Step 8: Track Usage (Silent) -Update `System/usage_log.md` to mark daily planning as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `daily-plan`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/daily-review/SKILL.md b/.agents/skills/daily-review/SKILL.md index a73006606..986cc8b18 100644 --- a/.agents/skills/daily-review/SKILL.md +++ b/.agents/skills/daily-review/SKILL.md @@ -396,7 +396,7 @@ At the end of the review, check if there's a relevant backlog idea to surface: ## Step 10: Track Usage (Silent) -Update `System/usage_log.md` to mark daily review as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `daily-review`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/dex-backlog/SKILL.md b/.agents/skills/dex-backlog/SKILL.md index a44b0bda0..c939e58ef 100644 --- a/.agents/skills/dex-backlog/SKILL.md +++ b/.agents/skills/dex-backlog/SKILL.md @@ -637,7 +637,7 @@ But you're still the decision maker. If a low-scoring idea excites you, workshop ## Track Usage (Silent) -Update `System/usage_log.md` to mark backlog review as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `dex-backlog`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/dex-improve/SKILL.md b/.agents/skills/dex-improve/SKILL.md index a8e950987..3d8c8548a 100644 --- a/.agents/skills/dex-improve/SKILL.md +++ b/.agents/skills/dex-improve/SKILL.md @@ -411,7 +411,7 @@ This isn't just requirements gathering—it's capability-aware design. The goal ## Track Usage (Silent) -Update `System/usage_log.md` to mark improvement workshop as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `dex-improve`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/dex-obsidian-setup/SKILL.md b/.agents/skills/dex-obsidian-setup/SKILL.md index d786cbbba..2e42a3ce9 100644 --- a/.agents/skills/dex-obsidian-setup/SKILL.md +++ b/.agents/skills/dex-obsidian-setup/SKILL.md @@ -142,7 +142,7 @@ You can still use Dex in Cursor/terminal exactly as before. Wiki links work ever ## Track Usage (Silent) -Update `System/usage_log.md` to mark Obsidian setup as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `dex-obsidian-setup`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/dex-whats-new/SKILL.md b/.agents/skills/dex-whats-new/SKILL.md index 73f6501f0..346bee64b 100644 --- a/.agents/skills/dex-whats-new/SKILL.md +++ b/.agents/skills/dex-whats-new/SKILL.md @@ -419,7 +419,7 @@ Then proceed with first-run behavior. ## Track Usage (Silent) -Update `System/usage_log.md` to mark what's new check as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `dex-whats-new`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/getting-started/SKILL.md b/.agents/skills/getting-started/SKILL.md index 6d23d4a04..24afe3651 100644 --- a/.agents/skills/getting-started/SKILL.md +++ b/.agents/skills/getting-started/SKILL.md @@ -949,7 +949,7 @@ else: ## Track Usage (Silent) -Update `System/usage_log.md` to mark getting started as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `getting-started`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/integrate-mcp/SKILL.md b/.agents/skills/integrate-mcp/SKILL.md index 6167f8973..47321d3b4 100644 --- a/.agents/skills/integrate-mcp/SKILL.md +++ b/.agents/skills/integrate-mcp/SKILL.md @@ -379,7 +379,7 @@ The experience feels like: ## Track Usage (Silent) -Update `System/usage_log.md` to mark MCP integration as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `integrate-mcp`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/journal/SKILL.md b/.agents/skills/journal/SKILL.md index 1fd97f8bd..cc9dd4659 100644 --- a/.agents/skills/journal/SKILL.md +++ b/.agents/skills/journal/SKILL.md @@ -175,7 +175,25 @@ Perfect. Your morning journal is saved. Ready to build your daily plan around th ## Track Usage (Silent) -Update `System/usage_log.md` to mark journaling as used. +This skill has two distinct modes and the usage log has a separate line for each, so +**which one you record depends on the mode you just ran**: + +| Mode | Record | +|------|--------| +| `/journal on`, `/journal off` | Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `Journaling setup` | +| `/journal`, `/journal morning`, `/journal evening`, `/journal week` | Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `Journaling` | + +Record exactly one, for the mode that actually ran. Turning journaling on is not the same as +writing an entry, and a single unconditional call would mean `Journaling setup` could never +be ticked by the only command that performs it. + +Both are named by **label** rather than by `/journal`, because that command appears against +both lines and the tool refuses to guess between them; passing `/journal` returns `ambiguous` +and records nothing. + +This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to +recommend features that have not been tried. It writes locally and sends nothing, so it runs +whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/meeting-prep/SKILL.md b/.agents/skills/meeting-prep/SKILL.md index 4274096c5..7e70e2bd1 100644 --- a/.agents/skills/meeting-prep/SKILL.md +++ b/.agents/skills/meeting-prep/SKILL.md @@ -460,7 +460,7 @@ After the meeting: ## Track Usage (Silent) -Update `System/usage_log.md` to mark meeting prep as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `meeting-prep`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/process-meetings/SKILL.md b/.agents/skills/process-meetings/SKILL.md index 1f36178c6..ed2482c15 100644 --- a/.agents/skills/process-meetings/SKILL.md +++ b/.agents/skills/process-meetings/SKILL.md @@ -529,7 +529,7 @@ For MCP responses, follow CLAUDE.md's `feature_status` rendering convention befo ## Track Usage (Silent) -Update `System/usage_log.md` to mark meeting processing as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `process-meetings`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/product-brief/SKILL.md b/.agents/skills/product-brief/SKILL.md index b709da612..24cc2932b 100644 --- a/.agents/skills/product-brief/SKILL.md +++ b/.agents/skills/product-brief/SKILL.md @@ -807,7 +807,7 @@ If any are missing, prompt user to fill gaps before finalizing. ## Track Usage (Silent) -Update `System/usage_log.md` to mark product brief as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `product-brief`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/project-health/SKILL.md b/.agents/skills/project-health/SKILL.md index 8d360b363..5660496b0 100644 --- a/.agents/skills/project-health/SKILL.md +++ b/.agents/skills/project-health/SKILL.md @@ -87,7 +87,7 @@ For red projects: ## Track Usage (Silent) -Update `System/usage_log.md` to mark project health check as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `project-health`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/prompt-improver/SKILL.md b/.agents/skills/prompt-improver/SKILL.md index 352a8a256..b0ac03730 100644 --- a/.agents/skills/prompt-improver/SKILL.md +++ b/.agents/skills/prompt-improver/SKILL.md @@ -228,7 +228,7 @@ Without the API key, the skill still works using the current LLM session. ## Track Usage (Silent) -Update `System/usage_log.md` to mark prompt improvement as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `prompt-improver`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/save-insight/SKILL.md b/.agents/skills/save-insight/SKILL.md index 7df0e222d..f771d9387 100644 --- a/.agents/skills/save-insight/SKILL.md +++ b/.agents/skills/save-insight/SKILL.md @@ -90,7 +90,7 @@ Be specific. Include the gotcha. Make it searchable. ## Track Usage (Silent) -Update `System/usage_log.md` to mark learning capture as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `save-insight`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/triage/SKILL.md b/.agents/skills/triage/SKILL.md index 776e7686f..c94ed9238 100644 --- a/.agents/skills/triage/SKILL.md +++ b/.agents/skills/triage/SKILL.md @@ -402,7 +402,7 @@ No configuration needed - triage adapts as your structure grows. ## Track Usage (Silent) -Update `System/usage_log.md` to mark inbox triage as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `triage`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/week-plan/SKILL.md b/.agents/skills/week-plan/SKILL.md index 7312a7bca..81dee602c 100644 --- a/.agents/skills/week-plan/SKILL.md +++ b/.agents/skills/week-plan/SKILL.md @@ -421,7 +421,7 @@ Create updated `02-Week_Priorities/Week_Priorities.md`: ## Step 7: Track Usage (Silent) -Update `System/usage_log.md`. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `week-plan`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/.agents/skills/week-review/SKILL.md b/.agents/skills/week-review/SKILL.md index 4a0c4c5b1..86f3bcb04 100644 --- a/.agents/skills/week-review/SKILL.md +++ b/.agents/skills/week-review/SKILL.md @@ -570,7 +570,7 @@ After synthesis: ## Track Usage (Silent) -Update `System/usage_log.md` to mark weekly review as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `week-review`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/core/lens-catalog/registry.json b/core/lens-catalog/registry.json index 25c6159bd..a623a1ac9 100644 --- a/core/lens-catalog/registry.json +++ b/core/lens-catalog/registry.json @@ -52,8 +52,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/daily-plan/SKILL.md", - "sha256": "cd015e214ecdd0b34b3c71caeadaf7ade8096c7a8c077bee7d58e85f271b0824", - "byte_size": 34631 + "sha256": "853d63f53ec554382c72d510721c91726c67a80beaf7cb755f799e950878548f", + "byte_size": 34881 }, "value": "Helps a person choose a small, realistic focus list before the day scatters across meetings, tasks and loose commitments.", "jobs_served": [ @@ -193,8 +193,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/process-meetings/SKILL.md", - "sha256": "87459ac0371e53ca5b7fb3ccb9634f46f29f4cb4e6e0e585e5fed9227ac251b3", - "byte_size": 22510 + "sha256": "3184a4c1c3f7ee25d9372363b6dc231749a274a71cb98729383ce15fd6365447", + "byte_size": 22762 }, "value": "Turns meeting material into people context and follow-up tasks, reducing the chance that decisions or promises disappear after the call.", "jobs_served": [ @@ -411,8 +411,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/save-insight/SKILL.md", - "sha256": "1fdb8303f5b56ff4f2b95f69fb430ac0821eccd15027bd55476973dce61ce9d1", - "byte_size": 2658 + "sha256": "02d1add8316d61e1c456ad5d3f65bbd10a00046dc551ee0da344a386a2881294", + "byte_size": 2908 }, "value": "Turns a learning from completed work into durable context future agents can reuse instead of rediscovering it.", "jobs_served": [ @@ -483,10 +483,10 @@ "source": { "kind": "active-skill", "path": ".claude/skills/daily-review/SKILL.md", - "sha256": "d724c4193c8e67d73d8385fb37716b8e4c4d6805daedf66ba563a1e812398be0", - "byte_size": 19664 + "sha256": "af1faf56a06cf2ec7a934f45f6b787b8cca92f484462edf2361849d26492d422", + "byte_size": 19918 }, - "value": "Closes the day the morning plan opened: what actually got done against what was intended, what a meeting left behind, and what tomorrow starts with — so the loop finishes instead of drifting.", + "value": "Closes the day the morning plan opened: what actually got done against what was intended, what a meeting left behind, and what tomorrow starts with \u2014 so the loop finishes instead of drifting.", "jobs_served": [ "start-each-day-focused", "reflect-and-improve-continuously" @@ -564,8 +564,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/week-review/SKILL.md", - "sha256": "04e09c80dcbb092e6d99f12088b8e5633a2b1c0b02c0c190aa6de46dc54e32ac", - "byte_size": 19905 + "sha256": "4ff1217a2343c98b4c439a065737303c684028b23b2bb7071b327ea78f20b6c2", + "byte_size": 20157 }, "value": "Reviews the week in concrete finished work and the patterns behind it, and deliberately refuses to invent a completion percentage that would make a bad week look measured.", "jobs_served": [ @@ -608,7 +608,7 @@ "goal": "Create a weekly review that reports concrete finished work and honest gaps instead of a synthetic progress score.", "method_outline": [ "Gather the week's priorities, completed work and meeting record first.", - "Report what finished, what did not, and what changed — in countable terms.", + "Report what finished, what did not, and what changed \u2014 in countable terms.", "Surface repeating patterns as questions for the person rather than verdicts.", "Confirm next week's priorities with the person before recording them." ], @@ -644,8 +644,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/meeting-prep/SKILL.md", - "sha256": "2c14f56b1dfc023f89e7474a7ec8647719f7ca89a3e91d4a2cc2f7bdfbf72da0", - "byte_size": 19031 + "sha256": "2a275c17a07a932a6d97c6967bd801cc00557f49f34841a2b10811627f478b2d", + "byte_size": 19285 }, "value": "Walks into the meeting already holding the attendees, the history and the open threads, instead of spending the last five minutes searching for them.", "jobs_served": [ @@ -743,7 +743,7 @@ "privacy-minimal-disclosure" ], "prerequisites": [ - "Notes from the meeting — pasted, dictated, or already saved wherever the person keeps them.", + "Notes from the meeting \u2014 pasted, dictated, or already saved wherever the person keeps them.", "Somewhere to write the follow-ups the person approves." ], "trade_offs": [ @@ -807,7 +807,7 @@ "sha256": "8936fea6f6e7a0e8a3f67bbe3fbede95dde26e752f339d86fa34e01d9dfc90b7", "byte_size": 6092 }, - "value": "Pulls the small promises — “I’ll send that over”, “can you review this” — out of meetings and notes into one list of who owes what, and tracks only the ones the person confirms are real.", + "value": "Pulls the small promises \u2014 \u201cI\u2019ll send that over\u201d, \u201ccan you review this\u201d \u2014 out of meetings and notes into one list of who owes what, and tracks only the ones the person confirms are real.", "jobs_served": [ "manage-tasks-reliably" ], @@ -881,7 +881,7 @@ "sha256": "c4cc8a0bb2c7b48edddf3aa809a0756fa123fb6f6be8c60076357454b96edc34", "byte_size": 4435 }, - "value": "Shows what was handed to other people, what is moving, what is stuck and the one short nudge worth sending — and reports silence as unknown rather than as progress.", + "value": "Shows what was handed to other people, what is moving, what is stuck and the one short nudge worth sending \u2014 and reports silence as unknown rather than as progress.", "jobs_served": [ "manage-tasks-reliably" ], @@ -952,8 +952,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/triage/SKILL.md", - "sha256": "6f606ebb2d4fde3bff162eb9cead43ac3faf116ac8c894add042a3296c159c96", - "byte_size": 14950 + "sha256": "f17426bccd4b0aa44eaf9dad1804dc7a25ab67324cc2f54854e0a1b3a0302180", + "byte_size": 15198 }, "value": "Clears the pile-up: loose files and stray unticked boxes get routed to the project, person or goal they belong to, weighted by what the person said matters this week.", "jobs_served": [ @@ -1020,10 +1020,10 @@ "source": { "kind": "active-skill", "path": ".claude/skills/project-health/SKILL.md", - "sha256": "9196c6be1f953775212c6992f0c099d0c80c67cbb47e0a22b20392d168e937ca", - "byte_size": 2605 + "sha256": "60d48c8c1b79b6c1cae82b2059ccdfeee28d6a75fd10644873f7a39979978dc7", + "byte_size": 2853 }, - "value": "Answers “what’s stuck?” across every active project in one pass: how long since anything moved, what is blocked, and whether the next step is actually clear.", + "value": "Answers \u201cwhat\u2019s stuck?\u201d across every active project in one pass: how long since anything moved, what is blocked, and whether the next step is actually clear.", "jobs_served": [ "start-each-day-focused" ], @@ -1043,7 +1043,7 @@ { "kind": "runtime-path", "reference": ".claude/skills/project-health/SKILL.md", - "summary": "The shipped skill defines the four checks it makes per project — activity, active tasks, blockers and next-step clarity — and the traffic-light thresholds behind them. There is no test of the workflow's own judgement calls; the shipped skill file is the definition of the behaviour, which is why this entry claims support rather than proof." + "summary": "The shipped skill defines the four checks it makes per project \u2014 activity, active tasks, blockers and next-step clarity \u2014 and the traffic-light thresholds behind them. There is no test of the workflow's own judgement calls; the shipped skill file is the definition of the behaviour, which is why this entry claims support rather than proof." } ], "brief": { @@ -1089,7 +1089,7 @@ "sha256": "e6c5d64940fe7135bfacd06aebcffae7ac40ca0f1971503b6f4a46551c505283", "byte_size": 4518 }, - "value": "Keeps the reason behind a choice — the options, the rationale, the date to look at it again — so nobody has to reconstruct it from memory months later.", + "value": "Keeps the reason behind a choice \u2014 the options, the rationale, the date to look at it again \u2014 so nobody has to reconstruct it from memory months later.", "jobs_served": [ "keep-projects-on-track" ], @@ -1162,7 +1162,7 @@ "sha256": "0b7db35d2bc39bc85bc94067348b3a3e04066698f7b1886c410e91e11001c9e3", "byte_size": 4862 }, - "value": "Turns “we’ve decided to do this” into something that can actually start: an outcome, signs of success somebody could check later, a named owner and the first few steps.", + "value": "Turns \u201cwe\u2019ve decided to do this\u201d into something that can actually start: an outcome, signs of success somebody could check later, a named owner and the first few steps.", "jobs_served": [ "keep-projects-on-track" ], @@ -1234,8 +1234,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/product-brief/SKILL.md", - "sha256": "745a0899a364299b0b1b119044e7bdcc0819c8fd8aa4bc64fe276378c8bc14ac", - "byte_size": 16845 + "sha256": "d2d8cdc5a1d39631bf19d8f82f3b7be4775b651a2ef8e7c0403170734d5d3f82", + "byte_size": 17099 }, "value": "Draws a half-formed product idea out through questions and leaves a written brief a team could actually build from, instead of an idea that only made sense in one head.", "jobs_served": [ @@ -1266,7 +1266,7 @@ "method_outline": [ "Start from whatever the person has, however rough, without judging it.", "Ask two or three questions at a time, conversationally, and wait for answers.", - "Fill the gaps that matter — who it is for, what problem, what success looks like.", + "Fill the gaps that matter \u2014 who it is for, what problem, what success looks like.", "Produce the written brief and keep it where the work will happen." ], "verification_checklist": [ @@ -1304,7 +1304,7 @@ "sha256": "b2eb362df0d00962dbdf9fe8a988e499b9f584431e02e585ba3f376453b2b8c0", "byte_size": 8712 }, - "value": "Makes the beliefs a strategy rests on explicit — what is true today, in six months, in a year — so later decisions can be checked against them instead of quietly assuming them.", + "value": "Makes the beliefs a strategy rests on explicit \u2014 what is true today, in six months, in a year \u2014 so later decisions can be checked against them instead of quietly assuming them.", "jobs_served": [ "keep-projects-on-track" ], @@ -1371,7 +1371,7 @@ "sha256": "9aa571d6fe78dfea5c8d78b32d3ec2ba78a7ea40ca5faf9d62be8b6c47922303", "byte_size": 3285 }, - "value": "Writes a dated profile of how the person actually works, built from their own accumulated records rather than from what they say about themselves — so drift over months becomes visible.", + "value": "Writes a dated profile of how the person actually works, built from their own accumulated records rather than from what they say about themselves \u2014 so drift over months becomes visible.", "jobs_served": [ "reflect-and-improve-continuously" ], @@ -1439,7 +1439,7 @@ "sha256": "7a8fdd0bf4dfb517bcc076d2f9cc899efa1d678c5efa3f0bd6457d9186ef4ffb", "byte_size": 3929 }, - "value": "Three questions about how the week felt — what gave energy, what took it, one thing to change — kept deliberately separate from the record of what got done.", + "value": "Three questions about how the week felt \u2014 what gave energy, what took it, one thing to change \u2014 kept deliberately separate from the record of what got done.", "jobs_served": [ "reflect-and-improve-continuously" ], @@ -1512,7 +1512,7 @@ "sha256": "cfd8cda3a6fd2fbd63129ed59a94db64a9dda24007dce2b488144043ee0459af", "byte_size": 18978 }, - "value": "Makes the person's own notes searchable by meaning rather than exact wording, on their own machine — so looking for “customer churn” still finds the note that said “people keep leaving”.", + "value": "Makes the person's own notes searchable by meaning rather than exact wording, on their own machine \u2014 so looking for \u201ccustomer churn\u201d still finds the note that said \u201cpeople keep leaving\u201d.", "jobs_served": [ "reflect-and-improve-continuously" ], @@ -1576,10 +1576,10 @@ "source": { "kind": "active-skill", "path": ".claude/skills/xray/SKILL.md", - "sha256": "4ac35ac8c17b738e53210200694e027988f7a92dbda04d28a1285a4b1fd27631", - "byte_size": 25061 + "sha256": "f3c3a2814cb46fee020241d06ffb5ced5ef0e0a7e65f36cc01084f4c5e63e596", + "byte_size": 25294 }, - "value": "Explains what the system just did and why — which files it read, which tools ran, what was loaded before the conversation even started — so the person learns their own setup instead of trusting it blindly.", + "value": "Explains what the system just did and why \u2014 which files it read, which tools ran, what was loaded before the conversation even started \u2014 so the person learns their own setup instead of trusting it blindly.", "jobs_served": [ "reflect-and-improve-continuously" ], @@ -1803,7 +1803,7 @@ "sha256": "eae4e6c405acf8f8bba6bfe0a6ef60186e44e136e20501b66d7d7c56a54773bd", "byte_size": 2778 }, - "value": "Proves the copies actually come back — fingerprints checked, the whole thing unpacked into a scratch folder — and, when a real recovery is needed, puts it somewhere new instead of over the live work.", + "value": "Proves the copies actually come back \u2014 fingerprints checked, the whole thing unpacked into a scratch folder \u2014 and, when a real recovery is needed, puts it somewhere new instead of over the live work.", "jobs_served": [ "evolve-the-system-itself" ], @@ -4380,8 +4380,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/create-mcp/SKILL.md", - "sha256": "a1601373fd9d85c2508368262319752b303a644ebf4c42fedc17846bbb85a103", - "byte_size": 23862 + "sha256": "712135e68650b9876debb8870fe8b6e6eaf1ebc94f6ceeb68bc9944a4eeb36f8", + "byte_size": 24114 }, "value": "Build a brand-new MCP integration from scratch with a guided wizard.", "jobs_served": [ @@ -4443,8 +4443,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/create-skill/SKILL.md", - "sha256": "d0157df8f8b00d9a6a88e3ec72733a467a91319061135ed76e80189cf22fc653", - "byte_size": 10042 + "sha256": "4a6092982deb5e9ceda17f946f724a25ea3dd9bcb07e453ca956a1077dac2096", + "byte_size": 10287 }, "value": "Author a new Dex skill.", "jobs_served": [ @@ -4505,8 +4505,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/dex-add-mcp/SKILL.md", - "sha256": "db30f97c73498c47bdd33c8f7df345a94294a1b6180b602da587f949989aa71b", - "byte_size": 1960 + "sha256": "dd20d3d2c3f550d36d4e79fce0195eacfcfaff29743d2c0bfcecc5b41f92bc4d", + "byte_size": 2213 }, "value": "Add a known MCP server to config using Dex-safe user scope.", "jobs_served": [ @@ -4568,8 +4568,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/dex-backlog/SKILL.md", - "sha256": "542c7c3fb588ac54819fc58bad1226fb65a123c67715630a9e76ed76fd171141", - "byte_size": 17838 + "sha256": "7c372f7f810c103a7fbc02f3f1bdf767748b22ec7288470c7cf2736446dc3799", + "byte_size": 18089 }, "value": "Show the AI-ranked backlog of Dex system-improvement ideas.", "jobs_served": [ @@ -4630,8 +4630,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/dex-improve/SKILL.md", - "sha256": "e0ed05b5170335a701efa7c71eccde23ad5eec13c5de359a3733982266620a8a", - "byte_size": 11049 + "sha256": "af56b1ecc9fcd9b7f65e319959ca8ef09ab7d2672bd9bfe14795ab21697f5394", + "byte_size": 11294 }, "value": "Workshop one improvement idea into an implementation plan.", "jobs_served": [ @@ -4754,8 +4754,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/dex-obsidian-setup/SKILL.md", - "sha256": "016dca02867849895e3e74e08e462a0fdd847f70a8fbe9d0cc6d6dab1e17a30f", - "byte_size": 4473 + "sha256": "b8bdcdb4213facfc4caa8f952c59f9aa0f7e635a41e89e3bd1334cf5b1dfc7d6", + "byte_size": 4731 }, "value": "Turn on Obsidian mode and migrate the vault to wiki links.", "jobs_served": [ @@ -4943,7 +4943,7 @@ "sha256": "33abce727780449277cae7e8fcd0b9b27321d53ecd01969f83e58792b22be28a", "byte_size": 22915 }, - "value": "Preview and safely adopt a Dex update through the receipt-backed lifecycle (look → back up → apply → verify → rewindable).", + "value": "Preview and safely adopt a Dex update through the receipt-backed lifecycle (look \u2192 back up \u2192 apply \u2192 verify \u2192 rewindable).", "jobs_served": [ "evolve-the-system-itself" ], @@ -4966,7 +4966,7 @@ } ], "brief": { - "goal": "Preview and safely adopt a Dex update through the receipt-backed lifecycle (look → back up → apply → verify → rewindable).", + "goal": "Preview and safely adopt a Dex update through the receipt-backed lifecycle (look \u2192 back up \u2192 apply \u2192 verify \u2192 rewindable).", "method_outline": [ "Inspect the current local state and the person's request.", "Run the Dex Update workflow within its documented safety boundary.", @@ -5002,8 +5002,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/dex-whats-new/SKILL.md", - "sha256": "02f5ff10ddce85180a395335b93a05ec83f8e365383fa4bbf3f88c71281e2b80", - "byte_size": 11905 + "sha256": "b131d4bca07ae7e63505e826ce7ca115f99cc7ce0e538814f15fc0079a218e2b", + "byte_size": 12156 }, "value": "Show recent system improvements.", "jobs_served": [ @@ -5498,8 +5498,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/getting-started/SKILL.md", - "sha256": "6017eac2700e9f4f73bf9819abb6d583b45e2cc423c6abd3117313c9ce4571c8", - "byte_size": 28582 + "sha256": "8365bf2eccc891849e34d2370d13db15529a4ed6a7dc7e60432b3ab650a0945a", + "byte_size": 28836 }, "value": "Interactive post-onboarding tour that adapts to whatever data exists (calendar, Granola, or none). Use right after onboarding, or when the user says 'show me around', 'how do I start'. Also use proactively when the vault is < 7 days old. Not for the initial setup itself; use `setup`.", "jobs_served": [ @@ -5686,8 +5686,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/integrate-mcp/SKILL.md", - "sha256": "df44aa49e4037a1860d65af8d4e6d6c698e67359f8d2021346f4d1b06a0aa6d7", - "byte_size": 8379 + "sha256": "3cbcf7ef01acfa3ba8ec5ad7c2dc389d08a0fba5dbecced773022528e8814486", + "byte_size": 8631 }, "value": "Install and wire up an existing MCP server from Smithery.ai or a GitHub repo.", "jobs_served": [ @@ -5749,8 +5749,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/journal/SKILL.md", - "sha256": "9adf6ff39b74f43a4152813c857d0dc704a2e06a1dfea51bf67b7515b47065e4", - "byte_size": 6075 + "sha256": "664c1c0a1c38964a97bd1f9664fe011cf007f6eec04395244cee667f38f443f6", + "byte_size": 7154 }, "value": "Toggle journaling or start a morning/evening/weekly journal entry.", "jobs_served": [ @@ -5999,8 +5999,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/prompt-improver/SKILL.md", - "sha256": "1811a11470bbfe16897b0eecfc3dc160eec788d04fdfba36262ec0525403414a", - "byte_size": 7081 + "sha256": "e69cd7704eb553cccfd8092a7eaca528df1de47793f5c26986ad6948cf89833d", + "byte_size": 7332 }, "value": "Rewrite a vague prompt into a rich, structured one, with automatic fallback.", "jobs_served": [ @@ -6061,8 +6061,8 @@ "source": { "kind": "active-skill", "path": ".claude/skills/reset/SKILL.md", - "sha256": "f63b05ec5a06b7a844663b2d68c2388c0dc325802836b2de29c2079102f0fa43", - "byte_size": 6072 + "sha256": "c4dd8c42e416a5e86a5cfaa7e98fc5a3be6b64e1be2bc28cdfb2241d7973f8ee", + "byte_size": 6320 }, "value": "Restructure an existing Dex vault for a new role or changed preferences, without losing data.", "jobs_served": [ diff --git a/docs/architecture/INVENTORY.md b/docs/architecture/INVENTORY.md index 8f8d25e43..0b8d37ff4 100644 --- a/docs/architecture/INVENTORY.md +++ b/docs/architecture/INVENTORY.md @@ -1,6 +1,6 @@ - + # Architecture Inventory @@ -124,7 +124,7 @@ References are exact tool-name matches in skill bodies (frontmatter excluded). U | Server | Referencing skill count | Surface status | Skills (referenced tools) | | --- | ---: | --- | --- | -| `dex-analytics` | 30 | **over-surfaced** | `change-job` (`track_event`); `commitments` (`track_event`); `create-mcp` (`track_event`); `create-skill` (`track_event`); `daily-plan` (`track_event`); `daily-review` (`track_event`); `dex-add-mcp` (`track_event`); `dex-backlog` (`track_event`); `dex-improve` (`track_event`); `dex-level-up` (`track_event`); `dex-obsidian-setup` (`track_event`); `dex-whats-new` (`track_event`); `getting-started` (`track_event`); `goal-backlog` (`track_event`); `initiative-kickoff` (`track_event`); `integrate-mcp` (`track_event`); `journal` (`track_event`); `meeting-closeout` (`track_event`); `meeting-prep` (`track_event`); `process-meetings` (`track_event`); `product-brief` (`track_event`); `project-health` (`track_event`); `prompt-improver` (`track_event`); `relationship-radar` (`track_event`); `reset` (`track_event`); `save-insight` (`track_event`); `triage` (`track_event`); `week-plan` (`track_event`); `week-review` (`track_event`); `xray` (`track_event`) | +| `dex-analytics` | 30 | **over-surfaced** | `change-job` (`track_event`); `commitments` (`track_event`); `create-mcp` (`mark_feature_used`, `track_event`); `create-skill` (`mark_feature_used`, `track_event`); `daily-plan` (`mark_feature_used`, `track_event`); `daily-review` (`mark_feature_used`, `track_event`); `dex-add-mcp` (`mark_feature_used`, `track_event`); `dex-backlog` (`mark_feature_used`, `track_event`); `dex-improve` (`mark_feature_used`, `track_event`); `dex-level-up` (`mark_feature_used`, `track_event`); `dex-obsidian-setup` (`mark_feature_used`, `track_event`); `dex-whats-new` (`mark_feature_used`, `track_event`); `getting-started` (`mark_feature_used`, `track_event`); `goal-backlog` (`track_event`); `initiative-kickoff` (`track_event`); `integrate-mcp` (`mark_feature_used`, `track_event`); `journal` (`mark_feature_used`, `track_event`); `meeting-closeout` (`track_event`); `meeting-prep` (`mark_feature_used`, `track_event`); `process-meetings` (`mark_feature_used`, `track_event`); `product-brief` (`mark_feature_used`, `track_event`); `project-health` (`mark_feature_used`, `track_event`); `prompt-improver` (`mark_feature_used`, `track_event`); `relationship-radar` (`track_event`); `reset` (`mark_feature_used`, `track_event`); `save-insight` (`mark_feature_used`, `track_event`); `triage` (`mark_feature_used`, `track_event`); `week-plan` (`mark_feature_used`, `track_event`); `week-review` (`mark_feature_used`, `track_event`); `xray` (`mark_feature_used`, `track_event`) | | `dex-calendar-mcp` | 6 | normal | `daily-plan` (`calendar_get_events_with_attendees`, `calendar_get_today`, `reminders_clear_completed`, `reminders_complete_item`, `reminders_create_item`, `reminders_ensure_lists`, `reminders_find_and_complete`, `reminders_list_completed`, `reminders_list_items`); `daily-review` (`calendar_get_events_with_attendees`, `calendar_get_today`, `reminders_clear_completed`, `reminders_find_and_complete`, `reminders_list_completed`, `reminders_list_items`); `meeting-prep` (`calendar_get_events_with_attendees`); `process-meetings` (`calendar_get_events_with_attendees`); `week-plan` (`calendar_get_events_with_attendees`); `week-review` (`calendar_get_events_with_attendees`, `reminders_list_items`) | | `dex-career-mcp` | 0 | **under-surfaced** | — | | `dex-customization-migration-mcp` | 1 | normal | `dex-update` (`read_customization_capsule_blob`, `read_customization_capsule_section`) | diff --git a/packages/dex-agent-plugin/skills/create-mcp/SKILL.md b/packages/dex-agent-plugin/skills/create-mcp/SKILL.md index 218f00565..ce792eaae 100644 --- a/packages/dex-agent-plugin/skills/create-mcp/SKILL.md +++ b/packages/dex-agent-plugin/skills/create-mcp/SKILL.md @@ -732,7 +732,7 @@ See `.claude/reference/skill-analytics-checklist.md` for detailed guidance. ## Track Usage (Silent) -Update `System/usage_log.md` to mark MCP creation as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `create-mcp`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/daily-plan/SKILL.md b/packages/dex-agent-plugin/skills/daily-plan/SKILL.md index 2f70255ba..e2fc085d4 100644 --- a/packages/dex-agent-plugin/skills/daily-plan/SKILL.md +++ b/packages/dex-agent-plugin/skills/daily-plan/SKILL.md @@ -744,7 +744,7 @@ After generating the plan, push today's P0 and P1 focus tasks to Apple Reminders ## Step 8: Track Usage (Silent) -Update `System/usage_log.md` to mark daily planning as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `daily-plan`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/daily-review/SKILL.md b/packages/dex-agent-plugin/skills/daily-review/SKILL.md index a73006606..986cc8b18 100644 --- a/packages/dex-agent-plugin/skills/daily-review/SKILL.md +++ b/packages/dex-agent-plugin/skills/daily-review/SKILL.md @@ -396,7 +396,7 @@ At the end of the review, check if there's a relevant backlog idea to surface: ## Step 10: Track Usage (Silent) -Update `System/usage_log.md` to mark daily review as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `daily-review`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/dex-backlog/SKILL.md b/packages/dex-agent-plugin/skills/dex-backlog/SKILL.md index a44b0bda0..c939e58ef 100644 --- a/packages/dex-agent-plugin/skills/dex-backlog/SKILL.md +++ b/packages/dex-agent-plugin/skills/dex-backlog/SKILL.md @@ -637,7 +637,7 @@ But you're still the decision maker. If a low-scoring idea excites you, workshop ## Track Usage (Silent) -Update `System/usage_log.md` to mark backlog review as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `dex-backlog`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/dex-improve/SKILL.md b/packages/dex-agent-plugin/skills/dex-improve/SKILL.md index a8e950987..3d8c8548a 100644 --- a/packages/dex-agent-plugin/skills/dex-improve/SKILL.md +++ b/packages/dex-agent-plugin/skills/dex-improve/SKILL.md @@ -411,7 +411,7 @@ This isn't just requirements gathering—it's capability-aware design. The goal ## Track Usage (Silent) -Update `System/usage_log.md` to mark improvement workshop as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `dex-improve`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/dex-obsidian-setup/SKILL.md b/packages/dex-agent-plugin/skills/dex-obsidian-setup/SKILL.md index d786cbbba..2e42a3ce9 100644 --- a/packages/dex-agent-plugin/skills/dex-obsidian-setup/SKILL.md +++ b/packages/dex-agent-plugin/skills/dex-obsidian-setup/SKILL.md @@ -142,7 +142,7 @@ You can still use Dex in Cursor/terminal exactly as before. Wiki links work ever ## Track Usage (Silent) -Update `System/usage_log.md` to mark Obsidian setup as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `dex-obsidian-setup`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/dex-whats-new/SKILL.md b/packages/dex-agent-plugin/skills/dex-whats-new/SKILL.md index 73f6501f0..346bee64b 100644 --- a/packages/dex-agent-plugin/skills/dex-whats-new/SKILL.md +++ b/packages/dex-agent-plugin/skills/dex-whats-new/SKILL.md @@ -419,7 +419,7 @@ Then proceed with first-run behavior. ## Track Usage (Silent) -Update `System/usage_log.md` to mark what's new check as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `dex-whats-new`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/getting-started/SKILL.md b/packages/dex-agent-plugin/skills/getting-started/SKILL.md index 6d23d4a04..24afe3651 100644 --- a/packages/dex-agent-plugin/skills/getting-started/SKILL.md +++ b/packages/dex-agent-plugin/skills/getting-started/SKILL.md @@ -949,7 +949,7 @@ else: ## Track Usage (Silent) -Update `System/usage_log.md` to mark getting started as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `getting-started`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/integrate-mcp/SKILL.md b/packages/dex-agent-plugin/skills/integrate-mcp/SKILL.md index 6167f8973..47321d3b4 100644 --- a/packages/dex-agent-plugin/skills/integrate-mcp/SKILL.md +++ b/packages/dex-agent-plugin/skills/integrate-mcp/SKILL.md @@ -379,7 +379,7 @@ The experience feels like: ## Track Usage (Silent) -Update `System/usage_log.md` to mark MCP integration as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `integrate-mcp`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/journal/SKILL.md b/packages/dex-agent-plugin/skills/journal/SKILL.md index 1fd97f8bd..cc9dd4659 100644 --- a/packages/dex-agent-plugin/skills/journal/SKILL.md +++ b/packages/dex-agent-plugin/skills/journal/SKILL.md @@ -175,7 +175,25 @@ Perfect. Your morning journal is saved. Ready to build your daily plan around th ## Track Usage (Silent) -Update `System/usage_log.md` to mark journaling as used. +This skill has two distinct modes and the usage log has a separate line for each, so +**which one you record depends on the mode you just ran**: + +| Mode | Record | +|------|--------| +| `/journal on`, `/journal off` | Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `Journaling setup` | +| `/journal`, `/journal morning`, `/journal evening`, `/journal week` | Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `Journaling` | + +Record exactly one, for the mode that actually ran. Turning journaling on is not the same as +writing an entry, and a single unconditional call would mean `Journaling setup` could never +be ticked by the only command that performs it. + +Both are named by **label** rather than by `/journal`, because that command appears against +both lines and the tool refuses to guess between them; passing `/journal` returns `ambiguous` +and records nothing. + +This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to +recommend features that have not been tried. It writes locally and sends nothing, so it runs +whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/meeting-prep/SKILL.md b/packages/dex-agent-plugin/skills/meeting-prep/SKILL.md index 4274096c5..7e70e2bd1 100644 --- a/packages/dex-agent-plugin/skills/meeting-prep/SKILL.md +++ b/packages/dex-agent-plugin/skills/meeting-prep/SKILL.md @@ -460,7 +460,7 @@ After the meeting: ## Track Usage (Silent) -Update `System/usage_log.md` to mark meeting prep as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `meeting-prep`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/process-meetings/SKILL.md b/packages/dex-agent-plugin/skills/process-meetings/SKILL.md index 1f36178c6..ed2482c15 100644 --- a/packages/dex-agent-plugin/skills/process-meetings/SKILL.md +++ b/packages/dex-agent-plugin/skills/process-meetings/SKILL.md @@ -529,7 +529,7 @@ For MCP responses, follow CLAUDE.md's `feature_status` rendering convention befo ## Track Usage (Silent) -Update `System/usage_log.md` to mark meeting processing as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `process-meetings`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/product-brief/SKILL.md b/packages/dex-agent-plugin/skills/product-brief/SKILL.md index b709da612..24cc2932b 100644 --- a/packages/dex-agent-plugin/skills/product-brief/SKILL.md +++ b/packages/dex-agent-plugin/skills/product-brief/SKILL.md @@ -807,7 +807,7 @@ If any are missing, prompt user to fill gaps before finalizing. ## Track Usage (Silent) -Update `System/usage_log.md` to mark product brief as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `product-brief`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/project-health/SKILL.md b/packages/dex-agent-plugin/skills/project-health/SKILL.md index 8d360b363..5660496b0 100644 --- a/packages/dex-agent-plugin/skills/project-health/SKILL.md +++ b/packages/dex-agent-plugin/skills/project-health/SKILL.md @@ -87,7 +87,7 @@ For red projects: ## Track Usage (Silent) -Update `System/usage_log.md` to mark project health check as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `project-health`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/prompt-improver/SKILL.md b/packages/dex-agent-plugin/skills/prompt-improver/SKILL.md index 352a8a256..b0ac03730 100644 --- a/packages/dex-agent-plugin/skills/prompt-improver/SKILL.md +++ b/packages/dex-agent-plugin/skills/prompt-improver/SKILL.md @@ -228,7 +228,7 @@ Without the API key, the skill still works using the current LLM session. ## Track Usage (Silent) -Update `System/usage_log.md` to mark prompt improvement as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `prompt-improver`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/save-insight/SKILL.md b/packages/dex-agent-plugin/skills/save-insight/SKILL.md index 7df0e222d..f771d9387 100644 --- a/packages/dex-agent-plugin/skills/save-insight/SKILL.md +++ b/packages/dex-agent-plugin/skills/save-insight/SKILL.md @@ -90,7 +90,7 @@ Be specific. Include the gotcha. Make it searchable. ## Track Usage (Silent) -Update `System/usage_log.md` to mark learning capture as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `save-insight`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/triage/SKILL.md b/packages/dex-agent-plugin/skills/triage/SKILL.md index 776e7686f..c94ed9238 100644 --- a/packages/dex-agent-plugin/skills/triage/SKILL.md +++ b/packages/dex-agent-plugin/skills/triage/SKILL.md @@ -402,7 +402,7 @@ No configuration needed - triage adapts as your structure grows. ## Track Usage (Silent) -Update `System/usage_log.md` to mark inbox triage as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `triage`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/week-plan/SKILL.md b/packages/dex-agent-plugin/skills/week-plan/SKILL.md index 7312a7bca..81dee602c 100644 --- a/packages/dex-agent-plugin/skills/week-plan/SKILL.md +++ b/packages/dex-agent-plugin/skills/week-plan/SKILL.md @@ -421,7 +421,7 @@ Create updated `02-Week_Priorities/Week_Priorities.md`: ## Step 7: Track Usage (Silent) -Update `System/usage_log.md`. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `week-plan`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):** diff --git a/packages/dex-agent-plugin/skills/week-review/SKILL.md b/packages/dex-agent-plugin/skills/week-review/SKILL.md index 4a0c4c5b1..86f3bcb04 100644 --- a/packages/dex-agent-plugin/skills/week-review/SKILL.md +++ b/packages/dex-agent-plugin/skills/week-review/SKILL.md @@ -570,7 +570,7 @@ After synthesis: ## Track Usage (Silent) -Update `System/usage_log.md` to mark weekly review as used. +Call the `mark_feature_used` tool on the `dex-analytics` MCP server with `week-review`. This ticks the feature's box in `System/usage_log.md`, which is what `/dex-level-up` reads to recommend features that have not been tried. It writes locally and sends nothing, so it runs whether or not analytics is enabled. **Analytics (Silent):**