Sync ctx 0a04cb6

GitHub commit: 0a04cb681b600359207835d19ab2669a49aa2d53

CHANGELOG.md

@@ -5,6 +5,12 @@ Format loosely follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+### Added
+
+- Added the LoopFlow/custom agent-loop adapter
+  (`python -m ctx.adapters.loopflow`) for permissioned pre-plan skill, agent,
+  MCP, ctx MCP server, and user-owned model harness recommendations.
+
 ### Changed
 
 - Hardened docs deploy and release publish gates so feature and dashboard

README.md

@@ -18,7 +18,7 @@ tags:
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![Python 3.11+](https://img.shields.io/badge/Python-3.11+-green.svg)](https://python.org)
 [![PyPI](https://img.shields.io/pypi/v/claude-ctx.svg)](https://pypi.org/project/claude-ctx/)
-[![Tests](https://img.shields.io/badge/Tests-4400_inventory-brightgreen.svg)](https://github.com/stevesolun/ctx/actions/workflows/test.yml)
+[![Tests](https://img.shields.io/badge/Tests-4421_inventory-brightgreen.svg)](https://github.com/stevesolun/ctx/actions/workflows/test.yml)
 [![Graph](https://img.shields.io/badge/Graph-79%2C958_nodes_/_1%2C778%2C069_edges-red.svg)](https://stevesolun.github.io/ctx/knowledge-graph/)
 [![Skills](https://img.shields.io/badge/Skills-68%2C494-blue.svg)](https://stevesolun.github.io/ctx/catalog/?type=skill)
 [![Agents](https://img.shields.io/badge/Agents-467-purple.svg)](https://stevesolun.github.io/ctx/catalog/?type=agent)
@@ -36,9 +36,10 @@ burn fewer tokens and local models waste less CPU/GPU work.
 
 ctx watches what you are building, walks a **79,958-node** graph, and
 recommends a small, top-scored bundle of skills, agents, and MCP servers for
-the current task. If you use your own local/API model instead of Claude Code,
-ctx has a separate harness setup flow: tell it the model and goal, review the
-recommended harness, then install with dry-run/update/uninstall controls.
+the current task. If you use your own local/API model instead of Claude Code or
+run an external loop such as LoopFlow, ctx has separate harness and adapter
+flows: tell it the model and goal, review recommendations, and keep installs
+behind dry-run/update/uninstall controls.
 
 Current shipped snapshot:
 
@@ -73,6 +74,7 @@ Examples from that tracker:
 | --- | --- | --- |
 | `CLI-002` | As a user I can ask ctx for current repo recommendations. | `ctx-recommend` returns a capped, graph-scored bundle of relevant skills, agents, and MCP servers from the shared recommendation engine. |
 | `CLI-026` | As a local/API model user I can get harness recommendations and install one. | `ctx-harness-install --dry-run` interviews model/goals/tools/privacy, recommends a fitting harness above threshold, or emits a no-fit custom harness PRD. |
+| `CLI-049` | As a DSL runner or custom agent-loop author I can ask ctx for scoped planning capabilities before each loop plan. | `python -m ctx.adapters.loopflow` emits a permission-gated JSON contract with skill, agent, MCP, ctx MCP server, and gated harness recommendations. |
 | `API-011` | As a dashboard user I can manually add, edit, or delete entities. | `/api/entity/upsert` and `/api/entity/delete` validate type, slug, and body, then queue safe graph/wiki updates instead of mutating blindly. |
 
 ## Install
@@ -95,7 +97,7 @@ Graph-backed recommendations need the pre-built graph. By default, `ctx-init
 in source checkouts, or the matching GitHub release asset from pip installs.
 It contains `graphify-out/*`, the shipped skill index needed for
 recommendations, and the 207 harness pages needed by
-`ctx-harness-install`:
+`ctx-harness-install` and LoopFlow adapter harness recommendations:
 
 ```bash
 ctx-init --graph
@@ -133,6 +135,7 @@ ctx-harness-install text-to-cad --dry-run   # inspect before cloning/running any
 ctx-harness-install text-to-cad             # install after reviewing the plan
 ctx-harness-install text-to-cad --update --dry-run
 ctx-harness-install text-to-cad --uninstall --dry-run
+python -m ctx.adapters.loopflow --goal "fix checkout e2e" --permissions skills,agents,mcps
 ctx-skill-quality list     # four-signal quality score for every skill
 ctx-skill-quality explain python-patterns   # drill into a single skill
 ctx-skill-health dashboard # structural health + drift detection

docs/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: skill-router
-description: "Repo-aware recommendation manager for ctx. Scans the active repository, identifies stack and workflow signals, recommends a capped set of skills, agents, and MCP servers, and unloads helpers that no longer match the current work after user confirmation. Harnesses are recommended by the custom-model onboarding flow and then attach to the same recommendation layer."
+description: "Repo-aware recommendation manager for ctx. Scans the active repository, identifies stack and workflow signals, recommends a capped set of skills, agents, and MCP servers, and unloads helpers that no longer match the current work after user confirmation. Harnesses are recommended by the custom-model onboarding flow or loop adapters and then attach to the same recommendation layer."
 ---
 
 # Skill Router
@@ -17,8 +17,9 @@ The router manages runtime recommendations for:
 - MCP servers
 
 Harnesses are separate catalog entities. They are recommended when a user wants
-to run ctx with a non-Claude-Code host, local model, or API model. Once attached,
-the harness calls the same skills/agents/MCP recommendation engine.
+to run ctx with a non-Claude-Code host, local model, API model, or external loop
+adapter. Once attached, the harness calls the same skills/agents/MCP
+recommendation engine.
 
 ## Problem
 
@@ -38,7 +39,7 @@ ctx/
 |-- src/scan_repo.py                         # Repo scanner -> stack profile
 |-- src/ctx/core/resolve/resolve_skills.py   # Profile -> load/unload manifest
 |-- src/ctx/core/resolve/recommendations.py  # Shared scoring/ranking engine
-|-- src/ctx/adapters/                        # Claude Code hooks + generic tools
+|-- src/ctx/adapters/                        # Host adapters + generic tools
 |-- src/harness_install.py                   # Custom-model harness install flow
 `-- graph/wiki-graph-runtime.tar.gz          # Shipped graph/wiki runtime
 ```

docs/harness/attaching-to-hosts.md

@@ -1,6 +1,6 @@
 # Attaching ctx to any LLM host
 
-`ctx` ships three integration surfaces. Pick based on what your host
+`ctx` ships four integration surfaces. Pick based on what your host
 already supports:
 
 | Your host | Use |
@@ -8,10 +8,11 @@ already supports:
 | MCP-native (Claude Code, Claude Agent SDK, Cline, Goose, OpenHands, Continue) | **MCP server** — no Python, just spawn `ctx-mcp-server` |
 | Anything that isn't MCP-native but runs Python | **Python library** — `from ctx import recommend_bundle, ...` |
 | "I just want to run an agent and get recommendations" | **`ctx run` CLI** — our built-in harness |
+| LoopFlow or another loop that already owns plan/act/observe | **LoopFlow adapter** — `python -m ctx.adapters.loopflow` before planning |
 
-All three paths consume the **same** knowledge graph, llm-wiki, and
-quality scoring. Recommendations are identical; only the transport
-differs.
+All four paths consume the **same** knowledge graph, llm-wiki, and
+quality scoring inputs. Output shape and grouping can differ by host
+surface; the transport and permission contract decide what each loop sees.
 
 ---
 
@@ -242,6 +243,94 @@ process environment; secret values are not stored in the session log.
 
 ---
 
+## 4. LoopFlow and agent-loop adapter path
+
+DSL runners such as [LoopFlow](https://loopflow.live/) and custom agent loops
+already own the control flow: plan, act, observe, reflect, and stop when their
+gate passes. Use `python -m ctx.adapters.loopflow` when that loop should ask
+ctx which capabilities it may load before planning.
+
+For a presenter-ready walkthrough, see
+[LoopFlow adapter demo](loopflow-adapter-demo.md).
+
+The adapter emits a JSON contract with:
+
+- explicit permission grants for `skills`, `agents`, `mcps`, and `harnesses`;
+- the `ctx-mcp-server` command and ctx tool names when the permission contract
+  allows ctx-core tools;
+- ranked skill, agent, and MCP recommendations from the `ctx-recommend`
+  engine;
+- optional harness recommendations only when the loop declares a user-owned,
+  API, or local model.
+
+For LoopFlow, keep the `.loop` file in charge and call ctx before the plan:
+
+```bash
+python -m ctx.adapters.loopflow \
+  --loop-file rate-limit.loop \
+  --permissions skills,agents,mcps
+```
+
+Add `--last-failure-file .loopflow/last-failure.txt` only after the loop has
+written that file; omit it on the first run. The adapter uses that failure text
+for recommendation ranking and returns only `context.last_failure_present`, not
+the raw failure.
+
+The returned payload includes LoopFlow-ready hints for the granted groups:
+
+```loop
+use skills: security-review, code-review
+```
+
+Only installed/local skill rows are named in `loopflow.use_skills`. Installable
+catalog skills remain under `capabilities.skills` with `status: available` and
+their `install_command` metadata.
+
+When the LoopFlow run uses its own LLM rather than a hosted Claude Code
+session, grant harnesses and pass the model profile:
+
+```bash
+python -m ctx.adapters.loopflow \
+  --loop-file private-agent.loop \
+  --permissions skills,agents,mcps,harnesses \
+  --own-llm \
+  --model-provider ollama \
+  --model ollama/llama3.1 \
+  --harness-runtime "local workstation" \
+  --harness-tools "filesystem, shell, browser" \
+  --harness-privacy "no cloud prompts"
+```
+
+Other harness matching hints use the same names as the install flow:
+`--harness-autonomy`, `--harness-verify`, `--harness-attach-mode`, and
+`--api-key-env`.
+
+Generic agent loops can import the same adapter directly:
+
+```python
+from ctx.adapters.loopflow import recommend_for_loop
+
+plan_context = recommend_for_loop(
+    goal="fix checkout e2e flake",
+    loop_kind="agent-loop",
+    look_at=["tests/e2e", "playwright config"],
+    done_when=['"pytest tests/e2e -q" passes'],
+    last_failure=last_failure_text,
+    permissions={"skills", "agents", "mcps", "harnesses"},
+    own_llm=True,
+    model_provider="openrouter",
+    model="anthropic/claude-opus-4.7",
+)
+```
+
+Load only the groups that are explicitly granted in `permissions`. If
+`harnesses` is granted without `--own-llm`, `--model-provider`, or `--model`,
+the adapter returns a warning and no harness recommendations. The ctx MCP
+command and tool list are also permission-filtered; ctx tools that can operate
+across all capability groups only appear when all of those groups are granted.
+
+---
+
 ## Installed harness attachment
 
 `ctx-harness-install <slug>` creates `.ctx/attach/` inside the installed
@@ -280,8 +369,9 @@ ctx-harness-install --recommend \
 | You're comparing models and need a harness | 3 (CLI) |
 | No catalog harness fits your model/goal | generated custom harness plan |
 | You're building an IDE extension | 1 if the IDE speaks MCP (most do), else 2 |
+| You're building a DSL runner or agent loop | 4 (LoopFlow adapter) |
 
-All three paths share `~/.claude/skill-wiki/` as the source-of-truth
+All four paths share `~/.claude/skill-wiki/` as the source-of-truth
 corpus, so your recommendations are consistent regardless of the
 integration you pick.
 

docs/harness/loopflow-adapter-demo.md

@@ -0,0 +1,200 @@
+# LoopFlow adapter demo
+
+Use this page as presenter notes for the LoopFlow owner. The short version:
+LoopFlow stays the control language; ctx becomes a permissioned recommendation
+sidecar that tells the loop which skills, agents, MCP tools, and user-owned LLM
+harnesses are worth loading before the next plan.
+
+## 30-second pitch
+
+LoopFlow already owns the loop: `goal:`, `look at:`, plan, act, observe,
+reflect, and `done when`. ctx should not replace that. ctx should run before
+planning, read the same goal, verification checks, and failure context, and
+return a read-only JSON contract:
+
+- what the loop is allowed to load;
+- which skills, agents, MCP servers, and harnesses fit the current goal;
+- the `ctx-mcp-server` command and tool list for MCP-aware runners;
+- a dry-run harness install command only when the user declares their own
+  local/API model.
+
+## Demo loop
+
+```loop
+loop "select ctx capabilities":
+  goal: mcp agent loop local ollama filesystem
+  look at: the repo plan, AGENTS.md, and the last failure
+  done when "pytest src/tests/test_loopflow_adapter.py -q" passes
+  each cycle: plan, then act, then observe
+  when it fails: reflect, then plan again
+```
+
+## Demo command
+
+Run ctx immediately before LoopFlow plans:
+
+```bash
+python -m ctx.adapters.loopflow \
+  --goal "mcp agent loop local ollama filesystem" \
+  --loop-name "ctx capability selection" \
+  --permissions skills,agents,mcps,harnesses \
+  --own-llm \
+  --model-provider ollama \
+  --model ollama/llama3.1 \
+  --top-k 2
+```
+
+The same call can read a real `.loop` file:
+
+```bash
+python -m ctx.adapters.loopflow \
+  --loop-file select-capabilities.loop \
+  --permissions skills,agents,mcps,harnesses \
+  --own-llm \
+  --model-provider ollama \
+  --model ollama/llama3.1
+```
+
+Add `--last-failure-file .loopflow/last-failure.txt` after LoopFlow has written
+that file.
+
+## Example payload
+
+This excerpt is from the live adapter against the current ctx catalog. Exact
+recommendation names can change as the graph changes, but the contract shape is
+stable.
+
+```json
+{
+  "version": "ctx.loop_adapter.v1",
+  "adapter": "loopflow",
+  "permissions": {
+    "skills": true,
+    "agents": true,
+    "mcps": true,
+    "harnesses": true
+  },
+  "loopflow": {
+    "before_plan": "Call python -m ctx.adapters.loopflow before planning and inject this JSON as read-only context.",
+    "use_tools": "use tools from the \"ctx\" server",
+    "use_skills": "use skills: oocx-tfplan2md-agent-model-selection",
+    "harness_rule": "Only load harnesses when the loop runs on a user-owned/API/local LLM."
+  },
+  "mcp_server": {
+    "name": "ctx",
+    "command": "ctx-mcp-server",
+    "tools": [
+      "ctx__recommend_bundle",
+      "ctx__graph_query",
+      "ctx__wiki_search",
+      "ctx__wiki_get",
+      "ctx__observe_dev_event",
+      "ctx__load_entity",
+      "ctx__mark_entity_used",
+      "ctx__record_validation",
+      "ctx__record_escalation",
+      "ctx__unload_entity",
+      "ctx__session_end",
+      "ctx__session_state"
+    ]
+  },
+  "capabilities": {
+    "skills": [
+      {"name": "oocx-tfplan2md-agent-model-selection", "type": "skill", "status": "installed"},
+      {
+        "name": "nickcrew-claude-ctx-plugin-tool-selection",
+        "type": "skill",
+        "status": "available",
+        "source_catalog": "skill-index",
+        "install_command": "ctx-skill-install nickcrew-claude-ctx-plugin-tool-selection"
+      }
+    ],
+    "agents": [
+      {"name": "oss-investigator-local-git-agent", "type": "agent"},
+      {"name": "loop-operator", "type": "agent"}
+    ],
+    "mcps": [
+      {"name": "local-ollama-file-operations", "type": "mcp-server"},
+      {"name": "multi-model-advisor-ollama", "type": "mcp-server"}
+    ],
+    "harnesses": [
+      {"name": "autogen", "type": "harness", "fit_score": 1.0},
+      {"name": "langfuse", "type": "harness", "fit_score": 1.0}
+    ]
+  },
+  "agent_loop": {
+    "before_act": "Load only the granted capability groups from capabilities.*.",
+    "on_failure": "Pass the latest failure back as last_failure before the next plan.",
+    "harness_install": "ctx-harness-install --dry-run '--goal=mcp agent loop local ollama filesystem' --model-provider=ollama --model=ollama/llama3.1 -- autogen"
+  },
+  "warnings": []
+}
+```
+
+## How LoopFlow would consume it
+
+The smallest integration is a pre-plan hook:
+
+```python
+from ctx.adapters.loopflow import recommend_for_loop
+
+ctx_payload = recommend_for_loop(
+    goal=loop.goal,
+    loop_name=loop.name,
+    loop_kind="loopflow",
+    look_at=loop.look_at,
+    done_when=loop.done_when,
+    last_failure=loop.last_failure_text,
+    permissions={"skills", "agents", "mcps", "harnesses"},
+    own_llm=runner.uses_user_owned_model,
+    model_provider=runner.model_provider,
+    model=runner.model,
+)
+
+loop.add_readonly_context("ctx", ctx_payload)
+
+if ctx_payload["mcp_server"]["command"]:
+    runner.register_mcp_server(
+        name=ctx_payload["mcp_server"]["name"],
+        command=ctx_payload["mcp_server"]["command"],
+    )
+
+if ctx_payload["loopflow"]["use_skills"]:
+    loop.add_planning_hint(ctx_payload["loopflow"]["use_skills"])
+```
+
+After a failed observe step, LoopFlow passes the new failure text back into the
+next adapter call. That is the agent-loop back edge: LoopFlow keeps the retry
+logic, and ctx refreshes recommendations based on what just failed.
+
+## Permission model
+
+The adapter fails closed:
+
+- `--permissions skills` only returns skill recommendations.
+- `--permissions mcps` only returns MCP server recommendations unless all
+  capability groups are granted, which lets ctx MCP tools operate safely across
+  skills, agents, MCPs, and harnesses.
+- `--permissions harnesses` returns no harnesses unless `--own-llm`,
+  `--model-provider`, or `--model` is present.
+- `agent_loop.harness_install` is always a `--dry-run` command. It shows what
+  would be installed; it does not mutate the host.
+
+This lets a LoopFlow user decide whether a loop may use skills, agents, MCPs,
+or harnesses without giving ctx authority to bypass the loop's own gates.
+
+## Owner ask
+
+The integration proposal for LoopFlow is intentionally small:
+
+1. Add an optional `ctx` pre-plan hook in the LoopFlow runner.
+2. Let `.loop` users grant capability groups: `skills`, `agents`, `mcps`,
+   and `harnesses`.
+3. Inject the returned JSON as read-only context before planning.
+4. Register the ctx MCP server only when the adapter returns an MCP command.
+5. Surface `agent_loop.harness_install` as an explicit user action, not an
+   automatic install.
+
+That gives LoopFlow the ctx graph, llm-wiki, MCP server, skill recommender, and
+user-owned model harness recommendations while preserving LoopFlow's language,
+human gates, and `done when` verification model.

docs/index.md

@@ -16,10 +16,10 @@ burn fewer tokens and local models waste less CPU/GPU work.
 
 Watches what you develop, walks a knowledge graph of **68,494 skill pages, 467 agents, 10,790 MCP servers, and 207 cataloged harnesses**, and recommends the
 right execution bundle on the fly. The live execution bundle is skills,
-agents, and MCP servers only; custom/API/local model users get a separate
-harness recommendation based on model choice and task goal. You decide
-what to load, install, or adopt. Powered by a Karpathy LLM wiki with persistent
-memory that gets smarter every session.
+agents, and MCP servers only; custom/API/local model users and external loop
+adapters get separate harness recommendations based on model choice and task
+goal. You decide what to load, install, or adopt. Powered by a Karpathy LLM wiki
+with persistent memory that gets smarter every session.
 
 !!! tip "Install"
 
@@ -126,8 +126,9 @@ graph-based discovery:
   stack signals, walks the graph, and **recommends** relevant skills,
   agents, and MCP servers in real time — **nothing loads or
   installs without your approval**.
-- During custom/API/local model onboarding, `ctx-init` and
-  `ctx-harness-install` use the same graph to recommend harnesses
+- During custom/API/local model onboarding and LoopFlow/agent-loop adapter
+  calls, `ctx-init`, `ctx-harness-install`, and
+  `python -m ctx.adapters.loopflow` use the same graph to recommend harnesses
   above the configured harness match floor.
 
 The result: you always know what skills, agents, and MCP servers are available
@@ -190,7 +191,8 @@ ones are flagged. New ones self-ingest.
 
     Scans the active repo, detects the stack from file signatures, walks
     the stack matrix, loads exactly the skills that apply, and can
-    recommend supporting agents and MCP servers.
+    recommend supporting agents and MCP servers. Loop adapters can call
+    the same recommender before each plan.
 
     [:octicons-arrow-right-24: Router overview](skill-router/index.md) ·
     [Stack signatures](stack-signatures.md) ·
@@ -214,7 +216,7 @@ ones are flagged. New ones self-ingest.
     ---
 
     Current main is **v1.0.20** — MIT, CI-matrixed (Ubuntu 3.12 plus Windows/macOS 3.11/3.12),
-    4,400 test inventory. Adds enterprise OpenTelemetry-ready telemetry and
+    4,421 test inventory. Adds enterprise OpenTelemetry-ready telemetry and
     ships console scripts including `ctx-init`,
     `ctx-monitor` (local dashboard with graph + wiki + load/unload for
     skills, agents, and MCP servers, plus Harness Setup for user-owned LLMs),

docs/knowledge-graph.md

@@ -189,11 +189,12 @@ The helper `resolve_graph.load_graph()` does this for you.
 
 ### Via recommendation paths
 
-The graph backs two recommendation paths:
+The graph backs these recommendation paths:
 
 - Execution recommendation surfaces (`ctx.recommend_bundle`, MCP
-  `ctx__recommend_bundle`, generic harness tools, Claude Code hook
-  suggestions, and repo-scan advisory output) share
+  `ctx__recommend_bundle`, generic harness tools, LoopFlow/agent-loop
+  adapter capability recommendations, Claude Code hook suggestions, and
+  repo-scan advisory output) share
   `ctx.core.resolve.recommendations.recommend_by_tags` for skills,
   agents, and MCP servers. That engine ranks candidates by
   slug-token matches, tag overlap, graph degree, and semantic-cache
@@ -204,9 +205,10 @@ The graph backs two recommendation paths:
   extracted wiki has the skill index JSON but no graph nodes for
   those records, the same recommender falls back to the index file.
 - Harness recommendations are a separate path for custom/API/local
-  model onboarding (`ctx-init --model-mode custom ...`) and
-  `ctx-harness-install`. They use the same graph filtered to
-  `harness` nodes and the higher harness match floor from `config.json`.
+  model onboarding (`ctx-init --model-mode custom ...`),
+  `ctx-harness-install`, and LoopFlow/agent-loop adapter calls that declare a
+  user-owned/API/local model. They use the same graph filtered to `harness`
+  nodes and the higher harness match floor from `config.json`.
 - Repository scans still start from stack detections, then turn that profile
   into the same tag/query bundle used by the execution recommender. If a
   shipped graph is unavailable, scan output falls back to the legacy installed

docs/qa/feature-user-story-status.csv

@@ -47,6 +47,7 @@ CLI-045,CLI,Backup mirror CLI,"python -m backup_mirror create, snapshot-if-chang
 CLI-046,CLI,Generic harness planner evaluator and contract modes,"ctx run --planner, ctx run --evaluator, ctx run --contract","src/ctx/cli/run.py, src/tests/test_harness_planner.py, src/tests/test_harness_evaluator.py, src/tests/test_harness_contract.py",As a model-agnostic harness user I can run planning evaluation and contract review modes,ctx.cli.run exposes --planner --evaluator and --contract modes while preserving session and runtime semantics,Provider fixture or local test provider available,"python -m pytest src/tests/test_harness_planner.py src/tests/test_harness_evaluator.py src/tests/test_harness_contract.py -q",Tested Pass,harness planner evaluator and contract tests cover CLI parser runtime dispatch and persisted outputs.,,,,,2026-06-29,Split from broad CLI-001 so deep ctx.cli.run modes are explicit.
 CLI-047,CLI,Resume MCP restoration safety,ctx resume --restore-session-mcp and credential_env,src/ctx/cli/run.py and src/tests/test_harness_cli_run.py,As a returning harness user I can resume without restoring executable MCP metadata unless I opt in,ctx resume skips recorded MCP command and env metadata by default and restores credential_env only with explicit --restore-session-mcp,Recorded session fixture,python -m pytest src/tests/test_harness_cli_run.py -q,Tested Pass,test_harness_cli_run.py covers default skip restore opt-in and credential_env behavior.,,,,,2026-06-29,Tracks resume security semantics inside broad CLI-001.
 CLI-048,CLI,Harness update and uninstall controls,ctx-harness-install --update and ctx-harness-install --uninstall,src/harness_install.py and src/tests/test_harness_install.py,As a harness user I can dry-run update or uninstall an installed harness safely,Update and uninstall flows detect installed harness state show planned changes and avoid destructive surprises,Installed harness fixture,python -m pytest src/tests/test_harness_install.py -q,Tested Pass,test_harness_install.py covers update dry-run uninstall safety and missing-record behavior.,,,,,2026-06-29,Split from CLI-026 so install recommend update and uninstall semantics are separately tracked.
+CLI-049,CLI,LoopFlow and agent-loop adapter,python -m ctx.adapters.loopflow,src/ctx/adapters/loopflow.py and src/tests/test_loopflow_adapter.py,As a DSL runner or custom agent-loop author I can ask ctx for scoped planning capabilities before each loop plan,Adapter emits a JSON contract with permission-gated skills agents MCPs ctx MCP server metadata and gated harness recommendations only when a user-owned/API/local model is declared,Graph/wiki available or recommendation functions mocked,python -m pytest src/tests/test_loopflow_adapter.py -q,Tested Pass,test_loopflow_adapter.py covers loop-file parsing permission filtering MCP tool metadata harness gating shell-quoted harness install commands CLI JSON output and empty permission fail-closed behavior.,,,,,2026-06-30,Tracks the module entry point documented in docs/harness/attaching-to-hosts.md.
 HOOK-001,Hooks,Backup PostToolUse runtime hook,hooks/backup_on_change.py,hooks/backup_on_change.py and src/tests/test_quality_hook.py,As a Claude Code user I can snapshot tracked config changes from a PostToolUse hook,The hook reads stdin JSON detects tracked files runs snapshot-if-changed and always exits 0 so edits are not blocked,Temp Claude home and tracked config fixture needed,python -m pytest src/tests/test_quality_hook.py -q,Tested Pass,test_quality_hook.py covers root backup hook stdin parsing tracked-file dispatch snapshot reason shaping and nonblocking exit even when snapshot returns nonzero.,,,,,2026-06-30,Validated in Phase 2 runtime hook behavior slice without increasing the test inventory count.
 HOOK-002,Hooks,Quality Stop runtime hook,hooks/quality_on_session_end.py,hooks/quality_on_session_end.py and src/tests/test_quality_hook.py,As a Claude Code user I can refresh touched skill quality on session stop without blocking shutdown,The hook reads event state recomputes bounded touched slugs writes audit state and always exits 0 on advisory failures,Temp Claude home and skill event fixture needed,python -m pytest src/tests/test_quality_hook.py -q,Tested Pass,test_quality_hook.py covers touched slug selection state cutoff max slug cap missing file behavior and main nonblocking exit when recompute fails.,,,,,2026-06-30,Validated in Phase 2 runtime hook behavior slice without increasing the test inventory count.
 PYAPI-001,Python API,Public Python API,ctx.api and ctx top-level re-exports,src/ctx/api.py and src/ctx/__init__.py,As a harness author I can import ctx from Python without depending on internal modules,recommend_bundle graph_query wiki_search wiki_get list_all_entities default_wiki_dir and CtxCoreToolbox keep stable signatures safe defaults and top-level re-exports,Runtime wiki or synthetic fixture available,pytest src/tests/test_public_api.py -q,Tested Pass,test_public_api.py covers __all__ exports top-level re-exports signatures happy paths empty paths and telemetry privacy payloads.,,,,,2026-06-29,Added during canonical feature inventory gap pass.
@@ -106,6 +107,7 @@ DOC-NAV-005,Docs,Entity onboarding page,docs/entity-onboarding.md,mkdocs.yml nav
 DOC-NAV-006,Docs,Dashboard page,docs/dashboard.md,mkdocs.yml nav,As a dashboard user I can understand the local monitor,The page documents dashboard routes data sources and expected monitor workflows,Docs build environment available,python -m mkdocs build --strict --quiet plus tracker nav coverage test,Tested Pass,python -m mkdocs build --strict --quiet passed; tracker nav coverage test passed.,,,,,2026-06-29,Added for public MkDocs nav coverage enforcement.
 DOC-NAV-007,Docs,Telemetry page,docs/telemetry.md,mkdocs.yml nav,As an enterprise operator I can configure telemetry safely,The page documents OpenTelemetry configuration exporters privacy defaults and operational checks,Docs build environment available,python -m mkdocs build --strict --quiet plus tracker nav coverage test,Tested Pass,python -m mkdocs build --strict --quiet passed; tracker nav coverage test passed.,,,,,2026-06-29,Added for public MkDocs nav coverage enforcement.
 DOC-NAV-008,Docs,Harness host attachment page,docs/harness/attaching-to-hosts.md,mkdocs.yml nav,As a harness integrator I can attach ctx to supported hosts,The page describes host attachment expectations and verification steps for harness adoption,Docs build environment available,python -m mkdocs build --strict --quiet plus tracker nav coverage test,Tested Pass,python -m mkdocs build --strict --quiet passed; tracker nav coverage test passed.,,,,,2026-06-29,Added for public MkDocs nav coverage enforcement.
+DOC-NAV-027,Docs,LoopFlow adapter demo page,docs/harness/loopflow-adapter-demo.md,mkdocs.yml nav,As a LoopFlow integrator I can follow a presenter-ready adapter demo,The page documents permissioned adapter setup JSON output and safe host consumption,Docs build environment available,python -m mkdocs build --strict --quiet plus tracker nav coverage test,Tested Pass,python -m mkdocs build --strict --quiet passed; tracker nav coverage test passed.,,,,,2026-06-30,Added for public MkDocs nav coverage enforcement.
 DOC-NAV-009,Docs,Clean-host contract page,docs/harness/clean-host-contract.md,mkdocs.yml nav,As a release reviewer I can understand the clean host contract,The page documents clean environment install checks and what must pass for release confidence,Docs build environment available,python -m mkdocs build --strict --quiet plus tracker nav coverage test,Tested Pass,python -m mkdocs build --strict --quiet passed; tracker nav coverage test passed.,,,,,2026-06-29,Added for public MkDocs nav coverage enforcement.
 DOC-NAV-010,Docs,Toolbox overview page,docs/toolbox/index.md,mkdocs.yml nav,As a toolbox user I can understand toolbox capabilities,The page introduces toolbox configuration council execution hooks and related workflows,Docs build environment available,python -m mkdocs build --strict --quiet plus tracker nav coverage test,Tested Pass,python -m mkdocs build --strict --quiet passed; tracker nav coverage test passed.,,,,,2026-06-29,Added for public MkDocs nav coverage enforcement.
 DOC-NAV-011,Docs,Toolbox configuration page,docs/toolbox/configuration.md,mkdocs.yml nav,As a toolbox user I can configure ctx toolboxes,The page documents configuration files fields and expected toolbox behavior,Docs build environment available,python -m mkdocs build --strict --quiet plus tracker nav coverage test,Tested Pass,python -m mkdocs build --strict --quiet passed; tracker nav coverage test passed.,,,,,2026-06-29,Added for public MkDocs nav coverage enforcement.

docs/skill-router/index.md

@@ -2,8 +2,8 @@
 
 The skill router decides which skills, agents, and MCP servers are useful for
 the active repository and current development task. Harnesses are recommended in
-the custom-model onboarding flow; after a harness is attached, the same capped
-skills/agents/MCP recommendation layer can be used by that host.
+the custom-model onboarding flow or loop adapters; after a harness is attached,
+the same capped skills/agents/MCP recommendation layer can be used by that host.
 
 ## Problem
 
@@ -23,7 +23,7 @@ ctx/
 |-- src/scan_repo.py                         # Repo scanner -> stack profile
 |-- src/ctx/core/resolve/resolve_skills.py   # Profile -> load/unload manifest
 |-- src/ctx/core/resolve/recommendations.py  # Shared recommendation engine
-|-- src/ctx/adapters/                        # Claude Code hooks + generic tools
+|-- src/ctx/adapters/                        # Host adapters + generic tools
 `-- graph/wiki-graph-runtime.tar.gz          # Shipped graph/wiki runtime
 ```
 
@@ -37,8 +37,8 @@ ctx/
 5. Usage and quality signals are recorded so future recommendations improve.
 
 The same recommender is used by the CLI, MCP/library tools, Claude Code hooks,
-and attached harness hosts. Entry points should differ only in transport and
-confirmation UX, not in ranking logic.
+LoopFlow/agent-loop adapter, and attached harness hosts. Entry points should
+differ only in transport and confirmation UX, not in ranking logic.
 
 ## Reference Pages
 

graph/README.md

@@ -15,10 +15,11 @@ Current snapshot:
 - Long skill bodies are kept behind the configured micro-skill line gate; the
   shipped tarball excludes raw `SKILL.md.original` backups.
 
-The runtime recommendation paths use this graph in two ways:
+The runtime recommendation paths use this graph in these ways:
 
 - Development recommendations return skills, agents, and MCP servers only.
-- Custom/API/local model onboarding recommends harnesses using the higher harness fit floor in `src/config.json`.
+- Custom/API/local model onboarding and LoopFlow/agent-loop adapter calls
+  recommend harnesses using the higher harness fit floor in `src/config.json`.
 
 ## Files