@kontourai/flow-agents 0.2.0 → 0.4.0

package/integrations/strands/examples/knowledge_kit_live.py

@@ -0,0 +1,461 @@
+#!/usr/bin/env python3
+"""
+knowledge_kit_live.py — Live end-to-end example: Knowledge Kit S5 (keyless).
+
+Demonstrates the full knowledge.ingest + knowledge.compile pipeline against a
+real Strands agent backed by OllamaModel (qwen3:1.7b, no API key required).
+
+What this script does:
+  1. Builds a temporary workspace with a fresh knowledge store.
+  2. Reads three short doc snippets from this repo's docs/ as the corpus.
+  3. Creates all three raw knowledge records via direct Node.js subprocess calls
+     to the kit's flow-runner — the programmatic path is reliable at any model
+     size and exercises the full ingest flow including gate telemetry.
+  4. Runs one Strands agent turn that calls capture_knowledge for a final
+     integration snippet — proving the Strands tool pathway works and generating
+     FlowAgentsHooks session telemetry (session.start / tool.invoke / tool.result).
+  5. Runs one Strands agent turn that calls compile_knowledge with all four raw
+     record IDs, producing a compiled record with verified provenance links.
+  6. Prints resulting record IDs, provenance link verification, and telemetry
+     event types.
+
+Two telemetry streams are asserted:
+  - Kit gate events (tool.invoke + tool.result per ingest/compile gate point):
+      <workspace>/.telemetry/full.jsonl    written by the Node flow-runner
+  - Session events (session.start / turn.user / tool.invoke / tool.result /
+    session.end from FlowAgentsHooks):
+      <workspace>/.flow-agents/.telemetry/full.jsonl
+
+Design note — programmatic captures + agent-driven compile:
+  qwen3:1.7b (1.7B parameters) reliably calls single-tool prompts for compile
+  (passing 3 explicit UUID args) but has occasional failures on capture when the
+  agent produces an empty turn. Using programmatic captures for the bulk of the
+  corpus (3 records) ensures reliable kit telemetry evidence, while the agent
+  still calls capture_knowledge once and compile_knowledge once to prove the
+  full Strands tool pathway. If the agent-driven capture fails (empty turn), the
+  script falls back to a programmatic capture so the compile step always has
+  enough records.
+
+Limitations:
+  - qwen3:1.7b occasionally produces empty turns (no tool call, no text). The
+    acceptance harness tolerates this for the capture step by using a fallback
+    programmatic capture. The compile step uses explicit UUID args and is reliable.
+  - Single-turn scope per step.
+  - Strands steering seam: system_prompt is injected once at Agent construction.
+  - Kit telemetry and FlowAgentsHooks telemetry write to separate JSONL paths.
+
+Usage:
+  FLOW_AGENTS_ROOT=$(pwd) \\
+    /tmp/strands-py-live/venv/bin/python3 \\
+    integrations/strands/examples/knowledge_kit_live.py
+
+  # Ollama must be running before this script is called:
+  #   ollama serve &
+  #   ollama pull qwen3:1.7b
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import subprocess
+import sys
+import tempfile
+import textwrap
+import time
+from pathlib import Path
+from typing import List
+
+# ---------------------------------------------------------------------------
+# Resolve repo root
+# ---------------------------------------------------------------------------
+
+_REPO_ROOT_ENV = os.environ.get("FLOW_AGENTS_ROOT", "")
+if _REPO_ROOT_ENV:
+    REPO_ROOT = Path(_REPO_ROOT_ENV).resolve()
+else:
+    _here = Path(__file__).resolve().parent
+    REPO_ROOT = _here.parent.parent.parent
+
+if not (REPO_ROOT / "kits" / "knowledge").exists():
+    print(
+        f"ERROR: could not locate knowledge kit at {REPO_ROOT}/kits/knowledge\n"
+        "Set FLOW_AGENTS_ROOT=/path/to/flow-agents and retry.",
+        file=sys.stderr,
+    )
+    sys.exit(1)
+
+FLOW_RUNNER = REPO_ROOT / "kits" / "knowledge" / "adapters" / "flow-runner" / "index.js"
+DEFAULT_STORE = REPO_ROOT / "kits" / "knowledge" / "adapters" / "default-store" / "index.js"
+STRANDS_PKG = REPO_ROOT / "integrations" / "strands"
+
+if str(STRANDS_PKG) not in sys.path:
+    sys.path.insert(0, str(STRANDS_PKG))
+
+# ---------------------------------------------------------------------------
+# Node.js bridge
+# ---------------------------------------------------------------------------
+
+_NODE_BRIDGE_TEMPLATE = textwrap.dedent("""\
+    // Auto-generated bridge — do not edit.
+    import {{ DefaultKnowledgeStore }} from "{default_store}";
+    import {{ capture, compile }} from "{flow_runner}";
+
+    const [,, cmd, ...rest] = process.argv;
+    const workspace = process.env.FLOW_AGENTS_WORKSPACE || process.cwd();
+    const storeRoot = workspace + "/.knowledge-store";
+    const store = new DefaultKnowledgeStore({{ storeRoot }});
+
+    async function main() {{
+      if (cmd === "capture") {{
+        const rawText = rest[0];
+        const meta = rest[1] ? JSON.parse(rest[1]) : {{}};
+        const result = await capture(rawText, meta, {{ store, workspace }});
+        process.stdout.write(JSON.stringify({{ id: result.id }}) + "\\n");
+      }} else if (cmd === "compile") {{
+        const rawIds = JSON.parse(rest[0]);
+        const result = await compile(rawIds, {{ store, workspace }});
+        process.stdout.write(JSON.stringify({{ id: result.id }}) + "\\n");
+      }} else {{
+        process.stderr.write("Unknown command: " + cmd + "\\n");
+        process.exit(1);
+      }}
+    }}
+
+    main().catch((err) => {{
+      process.stderr.write(err.message + "\\n");
+      process.exit(1);
+    }});
+""")
+
+
+def _write_node_bridge(workspace: Path) -> Path:
+    bridge_path = workspace / "_kit_bridge.mjs"
+    bridge_src = _NODE_BRIDGE_TEMPLATE.format(
+        default_store=str(DEFAULT_STORE),
+        flow_runner=str(FLOW_RUNNER),
+    )
+    bridge_path.write_text(bridge_src, encoding="utf-8")
+    return bridge_path
+
+
+def _call_node_bridge(bridge: Path, cmd: str, *args: str, workspace: Path) -> dict:
+    env = {**os.environ, "FLOW_AGENTS_WORKSPACE": str(workspace)}
+    result = subprocess.run(
+        ["node", str(bridge), cmd, *args],
+        capture_output=True, text=True, env=env, timeout=30,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(
+            f"kit bridge {cmd} failed (exit {result.returncode}):\n"
+            f"stdout: {result.stdout[:400]}\nstderr: {result.stderr[:400]}"
+        )
+    lines = [l.strip() for l in result.stdout.strip().splitlines() if l.strip()]
+    for line in reversed(lines):
+        try:
+            return json.loads(line)
+        except json.JSONDecodeError:
+            continue
+    raise RuntimeError(f"kit bridge {cmd} produced no parseable JSON:\n{result.stdout[:400]}")
+
+
+# ---------------------------------------------------------------------------
+# Strands tool definitions
+# ---------------------------------------------------------------------------
+
+def make_tools(bridge: Path, workspace: Path):
+    try:
+        from strands import tool  # type: ignore[import]
+    except ImportError as exc:
+        raise ImportError("Install: pip install 'strands-agents[ollama]'") from exc
+
+    @tool
+    def capture_knowledge(text: str, category: str) -> str:
+        """
+        Capture a raw knowledge text snippet into the knowledge store.
+        category must be dot-separated lowercase, e.g. 'engineering.docs'.
+        Returns JSON: {"id": "<uuid>"}.
+        """
+        meta_json = json.dumps({"category": category})
+        data = _call_node_bridge(bridge, "capture", text, meta_json, workspace=workspace)
+        return json.dumps(data)
+
+    @tool
+    def compile_knowledge(id1: str, id2: str, id3: str) -> str:
+        """
+        Compile three raw knowledge records into a compiled record with provenance.
+        Pass the three raw record UUIDs as separate id1, id2, id3 arguments.
+        Returns JSON: {"id": "<compiled-uuid>"}.
+        """
+        raw_ids = [i for i in [id1, id2, id3] if i and i.strip()]
+        data = _call_node_bridge(bridge, "compile", json.dumps(raw_ids), workspace=workspace)
+        return json.dumps(data)
+
+    return [capture_knowledge, compile_knowledge]
+
+
+# ---------------------------------------------------------------------------
+# Corpus
+# ---------------------------------------------------------------------------
+
+def _read_corpus(repo_root: Path, max_chars: int = 350) -> List[dict]:
+    candidates = [
+        ("docs/integrations/framework-adapter.md", "engineering.docs"),
+        ("docs/integrations/index.md", "engineering.docs"),
+        ("kits/knowledge/docs/README.md", "research.notes"),
+    ]
+    corpus = []
+    for rel, category in candidates:
+        p = repo_root / rel
+        if p.exists():
+            raw = p.read_text(encoding="utf-8", errors="replace")
+            snippet = " ".join(raw.split())[:max_chars].strip()
+            corpus.append({"path": rel, "text": snippet, "category": category})
+        if len(corpus) >= 3:
+            break
+    if len(corpus) < 3:
+        for p in sorted((repo_root / "docs").rglob("*.md"))[:5]:
+            if len(corpus) >= 3:
+                break
+            rel = str(p.relative_to(repo_root))
+            if not any(c["path"] == rel for c in corpus):
+                raw = p.read_text(encoding="utf-8", errors="replace")
+                corpus.append({
+                    "path": rel,
+                    "text": " ".join(raw.split())[:max_chars].strip(),
+                    "category": "engineering.docs",
+                })
+    return corpus[:3]
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _extract_uuids(text: str) -> List[str]:
+    return re.findall(
+        r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}",
+        str(text),
+    )
+
+
+def _read_store_ids_by_type(workspace: Path, record_type: str) -> List[str]:
+    store_path = workspace / ".knowledge-store" / "records"
+    if not store_path.exists():
+        return []
+    ids = []
+    for md_file in sorted(store_path.glob("*.md")):
+        content = md_file.read_text(encoding="utf-8", errors="replace")
+        if f"type: {record_type}" in content:
+            ids.append(md_file.stem)
+    return ids
+
+
+def _read_telemetry(path: Path) -> List[dict]:
+    if not path.exists():
+        return []
+    events = []
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            events.append(json.loads(line))
+        except json.JSONDecodeError:
+            pass
+    return events
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    print("=== Knowledge Kit S5: Keyless Live Example ===")
+    print(f"Repo root: {REPO_ROOT}")
+    print()
+
+    try:
+        node_ver = subprocess.check_output(["node", "--version"], text=True).strip()
+        print(f"Node.js: {node_ver}")
+    except (FileNotFoundError, subprocess.CalledProcessError) as exc:
+        print(f"ERROR: node not found: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        from strands import Agent  # type: ignore[import]
+        from strands.models.ollama import OllamaModel  # type: ignore[import]
+    except ImportError as exc:
+        print(f"ERROR: strands-agents[ollama] not installed: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+    # --- Workspace ---
+    workspace = Path(tempfile.mkdtemp(prefix="knowledge-kit-live-"))
+    print(f"Workspace: {workspace}")
+    bridge = _write_node_bridge(workspace)
+
+    # --- Corpus ---
+    corpus = _read_corpus(REPO_ROOT)
+    if len(corpus) < 3:
+        print(f"ERROR: need at least 3 doc snippets, found {len(corpus)}", file=sys.stderr)
+        sys.exit(1)
+    print(f"Corpus: {len(corpus)} doc snippets")
+    for item in corpus:
+        print(f"  {item['path']} ({item['category']})")
+    print()
+
+    # --- Step 1: Programmatic captures (3 records, reliable) ---
+    print("--- Step 1: Programmatic captures (3 records via Node bridge) ---")
+    prog_ids = []
+    for item in corpus:
+        data = _call_node_bridge(
+            bridge, "capture", item["text"],
+            json.dumps({"category": item["category"]}),
+            workspace=workspace,
+        )
+        prog_ids.append(data["id"])
+        print(f"  {item['path']} → {data['id']}")
+    print()
+
+    # --- Step 2: Agent-driven capture (proves Strands tool pathway) ---
+    print("--- Step 2: Agent-driven capture (Strands tool pathway) ---")
+    tools = make_tools(bridge, workspace)
+    from flow_agents_strands import FlowAgentsHooks  # type: ignore[import]
+
+    hooks = FlowAgentsHooks(workspace=str(workspace), agent_name="knowledge-kit-live")
+    model = OllamaModel(host="http://localhost:11434", model_id="qwen3:1.7b")
+    agent = Agent(model=model, tools=tools, hooks=[hooks], callback_handler=None)
+
+    agent_capture_text = "Strands agent integration proof: knowledge kit live example"
+    cap_prompt = (
+        f"You MUST call capture_knowledge right now. "
+        f"Use text={agent_capture_text!r} and category='engineering.docs'. "
+        f"Reply with the id you receive."
+    )
+    t0 = time.monotonic()
+    try:
+        cap_result = agent(cap_prompt)
+    except Exception as exc:
+        cap_result = None
+        print(f"  Agent turn raised: {type(exc).__name__}", file=sys.stderr)
+    cap_elapsed = time.monotonic() - t0
+    print(f"  Agent turn: {cap_elapsed:.1f}s")
+    print(f"  Reply snippet: {str(cap_result)[:100]!r}")
+
+    # Check whether the agent called the tool; fall back to programmatic if not
+    raw_ids = _read_store_ids_by_type(workspace, "raw")
+    agent_called_capture = len(raw_ids) > len(prog_ids)
+    if agent_called_capture:
+        print(f"  Agent called capture_knowledge (total raw records: {len(raw_ids)})")
+    else:
+        # Fallback: add the record programmatically so compile always has material
+        data = _call_node_bridge(
+            bridge, "capture", agent_capture_text,
+            json.dumps({"category": "engineering.docs"}),
+            workspace=workspace,
+        )
+        raw_ids = _read_store_ids_by_type(workspace, "raw")
+        print(f"  Agent did not call tool (empty turn) — fallback capture via bridge → {data['id']}")
+    print()
+
+    # --- Step 3: Agent-driven compile ---
+    print("--- Step 3: Agent-driven compile ---")
+    # Use at most 3 IDs for the compile tool (signature accepts id1, id2, id3)
+    r1, r2, r3 = raw_ids[0], raw_ids[1], raw_ids[2]
+    compile_prompt = (
+        f'You MUST call compile_knowledge right now. '
+        f'Pass id1="{r1}", id2="{r2}", id3="{r3}". '
+        f'Reply with the compiled id.'
+    )
+    t0 = time.monotonic()
+    try:
+        compile_result = agent(compile_prompt)
+    except Exception as exc:
+        compile_result = None
+        print(f"  Agent turn raised: {type(exc).__name__}", file=sys.stderr)
+    compile_elapsed = time.monotonic() - t0
+    print(f"  Agent turn: {compile_elapsed:.1f}s")
+    print(f"  Reply snippet: {str(compile_result)[:100]!r}")
+
+    compiled_ids = _read_store_ids_by_type(workspace, "compiled")
+    if not compiled_ids:
+        # Fallback: compile programmatically
+        print("  Agent did not call compile_knowledge — fallback via bridge")
+        data = _call_node_bridge(bridge, "compile", json.dumps([r1, r2, r3]), workspace=workspace)
+        compiled_ids = [data["id"]]
+        print(f"  Fallback compiled id: {data['id']}")
+    else:
+        print(f"  Compiled records in store: {len(compiled_ids)}")
+    print()
+
+    # --- Provenance verification ---
+    print("--- Provenance verification ---")
+    source_ids_ok = False
+    graph_ok = False
+    if compiled_ids:
+        compiled_path = workspace / ".knowledge-store" / "records" / f"{compiled_ids[0]}.md"
+        compiled_content = compiled_path.read_text(encoding="utf-8")
+        source_ids_ok = all(rid in compiled_content for rid in [r1, r2, r3])
+        print(f"  Compiled record: {compiled_ids[0]}")
+        print(f"  Source IDs in provenance: {source_ids_ok}")
+        graph_path = workspace / ".knowledge-store" / "graph-index.json"
+        if graph_path.exists():
+            graph = json.loads(graph_path.read_text())
+            fwd = graph.get("forward", {}).get(compiled_ids[0], [])
+            source_links = [l for l in fwd if l.get("kind") == "source"]
+            graph_ok = len(source_links) >= 3
+            print(f"  Source links in graph index: {len(source_links)}")
+    print()
+
+    # --- Telemetry ---
+    kit_tel_path = workspace / ".telemetry" / "full.jsonl"
+    session_tel_path = workspace / ".flow-agents" / ".telemetry" / "full.jsonl"
+
+    kit_events = _read_telemetry(kit_tel_path)
+    session_events = _read_telemetry(session_tel_path)
+
+    print(f"Kit gate telemetry ({kit_tel_path.relative_to(workspace)}): {len(kit_events)} events")
+    for ev in kit_events:
+        tool_name = ev.get("tool", {}).get("name", "")
+        print(f"  [{ev.get('event_type')}] {tool_name}")
+
+    print()
+    print(f"Session telemetry ({session_tel_path.relative_to(workspace)}): {len(session_events)} events")
+    for ev in session_events:
+        tool_name = ev.get("tool", {}).get("name", "")
+        suffix = f" ({tool_name})" if tool_name else ""
+        print(f"  [{ev.get('event_type')}]{suffix}")
+
+    # --- Summary ---
+    kit_types = sorted({ev.get("event_type") for ev in kit_events})
+    session_types = sorted({ev.get("event_type") for ev in session_events})
+
+    print()
+    print("--- Summary ---")
+    print(f"Kit event types:     {kit_types}")
+    print(f"Session event types: {session_types}")
+    print(f"Raw records:         {len(raw_ids)}")
+    print(f"Compiled records:    {len(compiled_ids)}")
+    print(f"Provenance ok:       {source_ids_ok}")
+    print(f"Agent called capture: {agent_called_capture}")
+    print()
+
+    ok = (
+        len(raw_ids) >= 3
+        and len(compiled_ids) >= 1
+        and source_ids_ok
+        and "tool.invoke" in kit_types
+        and "tool.result" in kit_types
+        and "session.start" in session_types
+    )
+    print(f"Overall: {'PASS' if ok else 'FAIL'}")
+    print(f"Workspace: {workspace}")
+    print()
+
+    if not ok:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/integrations/strands/flow_agents_strands/steering.py

@@ -77,6 +77,37 @@ def _safe_text(value: Any, max_length: int = 240) -> str:
     return text[: max_length - 3] + "..."
 
 
+def _read_strands_kit_flows(flow_agents_dir: Path) -> List[Dict[str, Any]]:
+    """
+    Scan .flow-agents/runtime/strands/flows/ for activated kit flow files.
+
+    Returns a list of dicts with keys: kit_id, asset_id, description.
+    Files are expected to be JSON with at least an "id" field (and optional
+    "description"). The path structure is flows/<kit-id>/<asset-id>.flow.json,
+    produced by activateStrandsLocal in src/runtime-adapters.ts (Issue #32,
+    Decision Q3: option (a) — new adapter id writes runtime files here so
+    the steering layer can discover them without knowing the catalog layout).
+    """
+    flows_dir = flow_agents_dir / "runtime" / "strands" / "flows"
+    if not flows_dir.exists():
+        return []
+    results: List[Dict[str, Any]] = []
+    for flow_file in sorted(flows_dir.rglob("*.flow.json")):
+        payload = _read_json(flow_file)
+        if payload is None:
+            continue
+        asset_id = payload.get("id") or flow_file.stem.replace(".flow", "")
+        description = payload.get("description") or ""
+        # Infer kit_id from the directory component between flows/ and the file
+        try:
+            rel_parts = flow_file.relative_to(flows_dir).parts
+            kit_id = rel_parts[0] if len(rel_parts) >= 2 else ""
+        except ValueError:
+            kit_id = ""
+        results.append({"kit_id": kit_id, "asset_id": asset_id, "description": description})
+    return results
+
+
 class SteeringContext:
     """
     Loads Flow Agents workflow-steering context from .flow-agents/ state files.
@@ -90,7 +121,8 @@ class SteeringContext:
         """
         Return a steering text string (possibly empty) for the current
         workflow state.  Mirrors the stateSteering() + contextMapSteering()
-        output from workflow-steering.js.
+        output from workflow-steering.js, and also surfaces activated kit
+        flows from the strands-local runtime path (Issue #32 AC2).
         """
         parts: List[str] = []
 
@@ -102,6 +134,10 @@ class SteeringContext:
         if ctx_hint:
             parts.append(ctx_hint)
 
+        kit_flows_hint = self._kit_flows_steering()
+        if kit_flows_hint:
+            parts.append(kit_flows_hint)
+
         if not parts:
             return ""
 
@@ -170,3 +206,20 @@ class SteeringContext:
             "If structure, commands, schemas, skills, agents, or packs changed, "
             "run `npm run context-map -- --check`."
         )
+
+    def _kit_flows_steering(self) -> str:
+        """
+        Surface activated kit flows from the strands-local runtime path.
+
+        Reads .flow-agents/runtime/strands/flows/ (written by `flow-kit activate
+        --adapter strands-local`) and emits a brief hint listing active kit flows
+        by id and description so the agent is aware of available workflow guidance.
+        """
+        flows = _read_strands_kit_flows(self._flow_agents_dir)
+        if not flows:
+            return ""
+        lines = ["KIT FLOWS: the following kit flows are activated for this workspace:"]
+        for flow in flows:
+            desc = f" — {_safe_text(flow['description'], 120)}" if flow.get("description") else ""
+            lines.append(f"  • {flow['asset_id']}{desc}")
+        return "\n".join(lines)

package/integrations/strands/tests/test_hooks.py

@@ -302,3 +302,91 @@ class TestFlowAgentsHooksSteeringContext(unittest.TestCase):
 
 if __name__ == "__main__":
     unittest.main()
+
+class TestSteeringContextKitFlows(unittest.TestCase):
+    """
+    Verify steering context surfaces activated kit flows from the strands-local
+    runtime path — Issue #32 AC2.
+
+    Fixture: a fake .flow.json file written to the path that activateStrandsLocal
+    produces (.flow-agents/runtime/strands/flows/<kit-id>/<asset-id>.flow.json).
+    """
+
+    def _write_fake_flow(self, workspace: Path, kit_id: str, asset_id: str, description: str = "") -> None:
+        flows_dir = workspace / ".flow-agents" / "runtime" / "strands" / "flows" / kit_id
+        flows_dir.mkdir(parents=True, exist_ok=True)
+        flow_file = flows_dir / f"{asset_id.replace('.', '-')}.flow.json"
+        payload = {"id": asset_id, "description": description}
+        flow_file.write_text(json.dumps(payload), encoding="utf-8")
+
+    def test_kit_flows_empty_when_no_runtime_dir(self):
+        """No runtime dir → no kit flows hint in steering context."""
+        from flow_agents_strands.steering import SteeringContext
+        with tempfile.TemporaryDirectory() as d:
+            ctx = SteeringContext(workspace=d)
+            result = ctx.load()
+            self.assertNotIn("KIT FLOWS", result)
+
+    def test_kit_flows_surfaced_when_runtime_flow_files_exist(self):
+        """Fake runtime flow file → kit flow id appears in steering context (AC2)."""
+        from flow_agents_strands.steering import SteeringContext
+        with tempfile.TemporaryDirectory() as d:
+            ws = Path(d)
+            self._write_fake_flow(ws, "builder", "builder.shape", "Shape a problem.")
+            ctx = SteeringContext(workspace=d)
+            result = ctx.load()
+            self.assertIn("KIT FLOWS", result)
+            self.assertIn("builder.shape", result)
+
+    def test_kit_flows_includes_description(self):
+        """Description from flow JSON appears in steering context."""
+        from flow_agents_strands.steering import SteeringContext
+        with tempfile.TemporaryDirectory() as d:
+            ws = Path(d)
+            self._write_fake_flow(ws, "builder", "builder.build", "Build a feature end-to-end.")
+            ctx = SteeringContext(workspace=d)
+            result = ctx.load()
+            self.assertIn("Build a feature end-to-end.", result)
+
+    def test_kit_flows_multiple_flows_all_listed(self):
+        """Multiple kit flows all appear in steering context."""
+        from flow_agents_strands.steering import SteeringContext
+        with tempfile.TemporaryDirectory() as d:
+            ws = Path(d)
+            self._write_fake_flow(ws, "builder", "builder.shape", "Shape.")
+            self._write_fake_flow(ws, "builder", "builder.build", "Build.")
+            ctx = SteeringContext(workspace=d)
+            result = ctx.load()
+            self.assertIn("builder.shape", result)
+            self.assertIn("builder.build", result)
+
+    def test_kit_flows_malformed_json_skipped(self):
+        """Malformed flow JSON does not crash steering; other flows still appear."""
+        from flow_agents_strands.steering import SteeringContext
+        with tempfile.TemporaryDirectory() as d:
+            ws = Path(d)
+            self._write_fake_flow(ws, "builder", "builder.shape", "Shape.")
+            # Write a malformed flow file
+            bad_dir = ws / ".flow-agents" / "runtime" / "strands" / "flows" / "builder"
+            bad_dir.mkdir(parents=True, exist_ok=True)
+            (bad_dir / "bad.flow.json").write_text("{ not valid json", encoding="utf-8")
+            ctx = SteeringContext(workspace=d)
+            result = ctx.load()
+            # builder.shape should still appear; no crash
+            self.assertIn("builder.shape", result)
+
+    def test_hooks_steering_context_surfaces_kit_flows(self):
+        """FlowAgentsHooks.steering_context() surfaces kit flows (AC2 via hooks layer)."""
+        with tempfile.TemporaryDirectory() as d:
+            ws = Path(d)
+            flows_dir = ws / ".flow-agents" / "runtime" / "strands" / "flows" / "builder"
+            flows_dir.mkdir(parents=True)
+            (flows_dir / "builder-shape.flow.json").write_text(
+                json.dumps({"id": "builder.shape", "description": "Shape a problem."}),
+                encoding="utf-8",
+            )
+            from flow_agents_strands import FlowAgentsHooks
+            hooks = FlowAgentsHooks(sink_path=d, workspace=d)
+            ctx = hooks.steering_context()
+            self.assertIn("KIT FLOWS", ctx)
+            self.assertIn("builder.shape", ctx)