docs/harness/loopflow-adapter-demo.md

# 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;
- which related recommendations fit after the loop accepts or rejects part of a
  previous bundle;
- 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
  ctx grants: skills, mcps, harnesses
  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 \
  --selected local-ollama-file-operations \
  --rejected legacy-reviewer \
  --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",
    "args": [],
    "tools": [
      "ctx__recommend_bundle",
      "ctx__graph_query",
      "ctx__recommend_related",
      "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",
        "installable": true,
        "load_status": "local-wiki",
        "source_path": "converted/oocx-tfplan2md-agent-model-selection/SKILL.md"
      },
      {
        "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",
        "installable": false,
        "load_status": "external-install-required",
        "source_path": "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}
    ]
  },
  "related_recommendations": [
    {
      "id": "mcp-server:ollama",
      "name": "ollama",
      "type": "mcp-server",
      "tldr": "mcp-server recommendation.",
      "reason": "related via local-ollama-file-operations; normalized score 1.000",
      "installable": true,
      "load_status": "local-wiki",
      "source_path": "entities/mcp-servers/ol/ollama.md",
      "selected": false,
      "selection_state": "suggested_related"
    }
  ],
  "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,
    selected=loop.selected_ctx_ids,
    rejected=loop.rejected_ctx_ids,
    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"],
        args=ctx_payload["mcp_server"]["args"],
    )

if ctx_payload["loopflow"]["use_skills"]:
    loop.add_planning_hint(ctx_payload["loopflow"]["use_skills"])

for row in ctx_payload["related_recommendations"]:
    loop.add_planning_hint(f"consider related ctx recommendation: {row['id']}")
```

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.
- Goals that imply local files, `feature_implementation`, no API keys, or a
  clear programming language overfetch and then hide non-local, credentialed,
  generic-planning, or wrong-language capability and related rows.
- `--permissions mcps` returns MCP server recommendations and exposes only
  read-only ctx MCP tools: recommendation, graph query, and wiki lookup.
- Lifecycle MCP tools such as load, mark-used, validation, escalation, unload,
  and session tools are exposed only when all capability groups are granted:
  `skills`, `agents`, `mcps`, and `harnesses`.
- `--permissions harnesses` returns no harnesses unless `--own-llm` is present.
  `--model-provider` and `--model` improve ranking and dry-run command metadata;
  they are not user-owned model consent.
- `agent_loop.harness_install` is always a `--dry-run` command. It shows what
  would be installed; it does not mutate the host.

`.loop` files can request ctx grants with one small line:

```loop
ctx grants: skills, mcps, harnesses
```

CLI/API grants take precedence. If the command passes `--permissions`, those
grants replace the `.loop` line. If the API caller passes `permissions=...`,
that explicit set is authoritative. If neither is present, the `.loop` grants
are used; if none are present anywhere, the adapter returns no capabilities.

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.