switchroom 0.5.0

package/skills/skill-creator/scripts/run_loop.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+"""Run the eval + improve loop until all pass or max iterations reached.
+
+Combines run_eval.py and improve_description.py in a loop, tracking history
+and returning the best description found. Supports train/test split to prevent
+overfitting.
+"""
+
+import argparse
+import json
+import random
+import sys
+import tempfile
+import time
+import webbrowser
+from pathlib import Path
+
+from scripts.generate_report import generate_html
+from scripts.improve_description import improve_description
+from scripts.run_eval import find_project_root, run_eval
+from scripts.utils import parse_skill_md
+
+
+def split_eval_set(eval_set: list[dict], holdout: float, seed: int = 42) -> tuple[list[dict], list[dict]]:
+    """Split eval set into train and test sets, stratified by should_trigger."""
+    random.seed(seed)
+
+    # Separate by should_trigger
+    trigger = [e for e in eval_set if e["should_trigger"]]
+    no_trigger = [e for e in eval_set if not e["should_trigger"]]
+
+    # Shuffle each group
+    random.shuffle(trigger)
+    random.shuffle(no_trigger)
+
+    # Calculate split points
+    n_trigger_test = max(1, int(len(trigger) * holdout))
+    n_no_trigger_test = max(1, int(len(no_trigger) * holdout))
+
+    # Split
+    test_set = trigger[:n_trigger_test] + no_trigger[:n_no_trigger_test]
+    train_set = trigger[n_trigger_test:] + no_trigger[n_no_trigger_test:]
+
+    return train_set, test_set
+
+
+def run_loop(
+    eval_set: list[dict],
+    skill_path: Path,
+    description_override: str | None,
+    num_workers: int,
+    timeout: int,
+    max_iterations: int,
+    runs_per_query: int,
+    trigger_threshold: float,
+    holdout: float,
+    model: str,
+    verbose: bool,
+    live_report_path: Path | None = None,
+    log_dir: Path | None = None,
+) -> dict:
+    """Run the eval + improvement loop."""
+    project_root = find_project_root()
+    name, original_description, content = parse_skill_md(skill_path)
+    current_description = description_override or original_description
+
+    # Split into train/test if holdout > 0
+    if holdout > 0:
+        train_set, test_set = split_eval_set(eval_set, holdout)
+        if verbose:
+            print(f"Split: {len(train_set)} train, {len(test_set)} test (holdout={holdout})", file=sys.stderr)
+    else:
+        train_set = eval_set
+        test_set = []
+
+    history = []
+    exit_reason = "unknown"
+
+    for iteration in range(1, max_iterations + 1):
+        if verbose:
+            print(f"\n{'='*60}", file=sys.stderr)
+            print(f"Iteration {iteration}/{max_iterations}", file=sys.stderr)
+            print(f"Description: {current_description}", file=sys.stderr)
+            print(f"{'='*60}", file=sys.stderr)
+
+        # Evaluate train + test together in one batch for parallelism
+        all_queries = train_set + test_set
+        t0 = time.time()
+        all_results = run_eval(
+            eval_set=all_queries,
+            skill_name=name,
+            description=current_description,
+            num_workers=num_workers,
+            timeout=timeout,
+            project_root=project_root,
+            runs_per_query=runs_per_query,
+            trigger_threshold=trigger_threshold,
+            model=model,
+        )
+        eval_elapsed = time.time() - t0
+
+        # Split results back into train/test by matching queries
+        train_queries_set = {q["query"] for q in train_set}
+        train_result_list = [r for r in all_results["results"] if r["query"] in train_queries_set]
+        test_result_list = [r for r in all_results["results"] if r["query"] not in train_queries_set]
+
+        train_passed = sum(1 for r in train_result_list if r["pass"])
+        train_total = len(train_result_list)
+        train_summary = {"passed": train_passed, "failed": train_total - train_passed, "total": train_total}
+        train_results = {"results": train_result_list, "summary": train_summary}
+
+        if test_set:
+            test_passed = sum(1 for r in test_result_list if r["pass"])
+            test_total = len(test_result_list)
+            test_summary = {"passed": test_passed, "failed": test_total - test_passed, "total": test_total}
+            test_results = {"results": test_result_list, "summary": test_summary}
+        else:
+            test_results = None
+            test_summary = None
+
+        history.append({
+            "iteration": iteration,
+            "description": current_description,
+            "train_passed": train_summary["passed"],
+            "train_failed": train_summary["failed"],
+            "train_total": train_summary["total"],
+            "train_results": train_results["results"],
+            "test_passed": test_summary["passed"] if test_summary else None,
+            "test_failed": test_summary["failed"] if test_summary else None,
+            "test_total": test_summary["total"] if test_summary else None,
+            "test_results": test_results["results"] if test_results else None,
+            # For backward compat with report generator
+            "passed": train_summary["passed"],
+            "failed": train_summary["failed"],
+            "total": train_summary["total"],
+            "results": train_results["results"],
+        })
+
+        # Write live report if path provided
+        if live_report_path:
+            partial_output = {
+                "original_description": original_description,
+                "best_description": current_description,
+                "best_score": "in progress",
+                "iterations_run": len(history),
+                "holdout": holdout,
+                "train_size": len(train_set),
+                "test_size": len(test_set),
+                "history": history,
+            }
+            live_report_path.write_text(generate_html(partial_output, auto_refresh=True, skill_name=name))
+
+        if verbose:
+            def print_eval_stats(label, results, elapsed):
+                pos = [r for r in results if r["should_trigger"]]
+                neg = [r for r in results if not r["should_trigger"]]
+                tp = sum(r["triggers"] for r in pos)
+                pos_runs = sum(r["runs"] for r in pos)
+                fn = pos_runs - tp
+                fp = sum(r["triggers"] for r in neg)
+                neg_runs = sum(r["runs"] for r in neg)
+                tn = neg_runs - fp
+                total = tp + tn + fp + fn
+                precision = tp / (tp + fp) if (tp + fp) > 0 else 1.0
+                recall = tp / (tp + fn) if (tp + fn) > 0 else 1.0
+                accuracy = (tp + tn) / total if total > 0 else 0.0
+                print(f"{label}: {tp+tn}/{total} correct, precision={precision:.0%} recall={recall:.0%} accuracy={accuracy:.0%} ({elapsed:.1f}s)", file=sys.stderr)
+                for r in results:
+                    status = "PASS" if r["pass"] else "FAIL"
+                    rate_str = f"{r['triggers']}/{r['runs']}"
+                    print(f"  [{status}] rate={rate_str} expected={r['should_trigger']}: {r['query'][:60]}", file=sys.stderr)
+
+            print_eval_stats("Train", train_results["results"], eval_elapsed)
+            if test_summary:
+                print_eval_stats("Test ", test_results["results"], 0)
+
+        if train_summary["failed"] == 0:
+            exit_reason = f"all_passed (iteration {iteration})"
+            if verbose:
+                print(f"\nAll train queries passed on iteration {iteration}!", file=sys.stderr)
+            break
+
+        if iteration == max_iterations:
+            exit_reason = f"max_iterations ({max_iterations})"
+            if verbose:
+                print(f"\nMax iterations reached ({max_iterations}).", file=sys.stderr)
+            break
+
+        # Improve the description based on train results
+        if verbose:
+            print(f"\nImproving description...", file=sys.stderr)
+
+        t0 = time.time()
+        # Strip test scores from history so improvement model can't see them
+        blinded_history = [
+            {k: v for k, v in h.items() if not k.startswith("test_")}
+            for h in history
+        ]
+        new_description = improve_description(
+            skill_name=name,
+            skill_content=content,
+            current_description=current_description,
+            eval_results=train_results,
+            history=blinded_history,
+            model=model,
+            log_dir=log_dir,
+            iteration=iteration,
+        )
+        improve_elapsed = time.time() - t0
+
+        if verbose:
+            print(f"Proposed ({improve_elapsed:.1f}s): {new_description}", file=sys.stderr)
+
+        current_description = new_description
+
+    # Find the best iteration by TEST score (or train if no test set)
+    if test_set:
+        best = max(history, key=lambda h: h["test_passed"] or 0)
+        best_score = f"{best['test_passed']}/{best['test_total']}"
+    else:
+        best = max(history, key=lambda h: h["train_passed"])
+        best_score = f"{best['train_passed']}/{best['train_total']}"
+
+    if verbose:
+        print(f"\nExit reason: {exit_reason}", file=sys.stderr)
+        print(f"Best score: {best_score} (iteration {best['iteration']})", file=sys.stderr)
+
+    return {
+        "exit_reason": exit_reason,
+        "original_description": original_description,
+        "best_description": best["description"],
+        "best_score": best_score,
+        "best_train_score": f"{best['train_passed']}/{best['train_total']}",
+        "best_test_score": f"{best['test_passed']}/{best['test_total']}" if test_set else None,
+        "final_description": current_description,
+        "iterations_run": len(history),
+        "holdout": holdout,
+        "train_size": len(train_set),
+        "test_size": len(test_set),
+        "history": history,
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Run eval + improve loop")
+    parser.add_argument("--eval-set", required=True, help="Path to eval set JSON file")
+    parser.add_argument("--skill-path", required=True, help="Path to skill directory")
+    parser.add_argument("--description", default=None, help="Override starting description")
+    parser.add_argument("--num-workers", type=int, default=10, help="Number of parallel workers")
+    parser.add_argument("--timeout", type=int, default=30, help="Timeout per query in seconds")
+    parser.add_argument("--max-iterations", type=int, default=5, help="Max improvement iterations")
+    parser.add_argument("--runs-per-query", type=int, default=3, help="Number of runs per query")
+    parser.add_argument("--trigger-threshold", type=float, default=0.5, help="Trigger rate threshold")
+    parser.add_argument("--holdout", type=float, default=0.4, help="Fraction of eval set to hold out for testing (0 to disable)")
+    parser.add_argument("--model", required=True, help="Model for improvement")
+    parser.add_argument("--verbose", action="store_true", help="Print progress to stderr")
+    parser.add_argument("--report", default="auto", help="Generate HTML report at this path (default: 'auto' for temp file, 'none' to disable)")
+    parser.add_argument("--results-dir", default=None, help="Save all outputs (results.json, report.html, log.txt) to a timestamped subdirectory here")
+    args = parser.parse_args()
+
+    eval_set = json.loads(Path(args.eval_set).read_text())
+    skill_path = Path(args.skill_path)
+
+    if not (skill_path / "SKILL.md").exists():
+        print(f"Error: No SKILL.md found at {skill_path}", file=sys.stderr)
+        sys.exit(1)
+
+    name, _, _ = parse_skill_md(skill_path)
+
+    # Set up live report path
+    if args.report != "none":
+        if args.report == "auto":
+            timestamp = time.strftime("%Y%m%d_%H%M%S")
+            live_report_path = Path(tempfile.gettempdir()) / f"skill_description_report_{skill_path.name}_{timestamp}.html"
+        else:
+            live_report_path = Path(args.report)
+        # Open the report immediately so the user can watch
+        live_report_path.write_text("<html><body><h1>Starting optimization loop...</h1><meta http-equiv='refresh' content='5'></body></html>")
+        webbrowser.open(str(live_report_path))
+    else:
+        live_report_path = None
+
+    # Determine output directory (create before run_loop so logs can be written)
+    if args.results_dir:
+        timestamp = time.strftime("%Y-%m-%d_%H%M%S")
+        results_dir = Path(args.results_dir) / timestamp
+        results_dir.mkdir(parents=True, exist_ok=True)
+    else:
+        results_dir = None
+
+    log_dir = results_dir / "logs" if results_dir else None
+
+    output = run_loop(
+        eval_set=eval_set,
+        skill_path=skill_path,
+        description_override=args.description,
+        num_workers=args.num_workers,
+        timeout=args.timeout,
+        max_iterations=args.max_iterations,
+        runs_per_query=args.runs_per_query,
+        trigger_threshold=args.trigger_threshold,
+        holdout=args.holdout,
+        model=args.model,
+        verbose=args.verbose,
+        live_report_path=live_report_path,
+        log_dir=log_dir,
+    )
+
+    # Save JSON output
+    json_output = json.dumps(output, indent=2)
+    print(json_output)
+    if results_dir:
+        (results_dir / "results.json").write_text(json_output)
+
+    # Write final HTML report (without auto-refresh)
+    if live_report_path:
+        live_report_path.write_text(generate_html(output, auto_refresh=False, skill_name=name))
+        print(f"\nReport: {live_report_path}", file=sys.stderr)
+
+    if results_dir and live_report_path:
+        (results_dir / "report.html").write_text(generate_html(output, auto_refresh=False, skill_name=name))
+
+    if results_dir:
+        print(f"Results saved to: {results_dir}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

package/skills/skill-creator/scripts/utils.py

@@ -0,0 +1,47 @@
+"""Shared utilities for skill-creator scripts."""
+
+from pathlib import Path
+
+
+
+def parse_skill_md(skill_path: Path) -> tuple[str, str, str]:
+    """Parse a SKILL.md file, returning (name, description, full_content)."""
+    content = (skill_path / "SKILL.md").read_text()
+    lines = content.split("\n")
+
+    if lines[0].strip() != "---":
+        raise ValueError("SKILL.md missing frontmatter (no opening ---)")
+
+    end_idx = None
+    for i, line in enumerate(lines[1:], start=1):
+        if line.strip() == "---":
+            end_idx = i
+            break
+
+    if end_idx is None:
+        raise ValueError("SKILL.md missing frontmatter (no closing ---)")
+
+    name = ""
+    description = ""
+    frontmatter_lines = lines[1:end_idx]
+    i = 0
+    while i < len(frontmatter_lines):
+        line = frontmatter_lines[i]
+        if line.startswith("name:"):
+            name = line[len("name:"):].strip().strip('"').strip("'")
+        elif line.startswith("description:"):
+            value = line[len("description:"):].strip()
+            # Handle YAML multiline indicators (>, |, >-, |-)
+            if value in (">", "|", ">-", "|-"):
+                continuation_lines: list[str] = []
+                i += 1
+                while i < len(frontmatter_lines) and (frontmatter_lines[i].startswith("  ") or frontmatter_lines[i].startswith("\t")):
+                    continuation_lines.append(frontmatter_lines[i].strip())
+                    i += 1
+                description = " ".join(continuation_lines)
+                continue
+            else:
+                description = value.strip('"').strip("'")
+        i += 1
+
+    return name, description, content

package/skills/switchroom-architecture/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: switchroom-architecture
+description: Explains how switchroom works internally — config cascade, profiles, settings resolution, agent lifecycle, plugin system. Use when the user asks 'how does switchroom work internally', 'how does the cascade decide', 'which settings apply', architecture, design, or internals. Do NOT use for onboarding or getting-started questions ('how do I get started', 'I'm new to switchroom', 'bootstrap from scratch', 'set up for the first time') — those belong to switchroom-install.
+user-invocable: false
+---
+
+# Switchroom Architecture Overview
+
+Switchroom is a multi-agent orchestrator built on Claude Code. It manages multiple Claude agents, each running as a persistent process with its own Telegram bot, memory collection, and configuration.
+
+## Key concepts
+
+**One `switchroom.yaml` to rule them all.** All agents are configured from a single file using a three-layer cascade. See [cascade.md](cascade.md) for full merge semantics.
+
+**Agents as systemd services.** Each agent runs as a long-lived `claude` process managed by a systemd user service (`switchroom-<name>.service`). The `start.sh` script sets environment variables and execs into `claude`. Claude Code handles session persistence and tool execution.
+
+**Telegram as the primary interface.** The `switchroom-telegram` MCP plugin connects Claude Code to Telegram, providing 10 tools for message handling. See [telegram.md](telegram.md) for details.
+
+**Hindsight for memory.** Cross-session memory uses the Hindsight MCP server — a semantic vector store with knowledge graphs, mental models, and directives. Each agent has its own named collection.
+
+**Skills as reusable behavior.** Shared skills live in `~/.switchroom/skills/` (or `switchroom.skills_dir`). Scaffold symlinks selected skills into each agent's `skills/` directory. Claude Code loads them at session start.
+
+## Directory layout
+
+```
+~/.switchroom/
+├── switchroom.yaml              # master config
+├── vault.enc               # encrypted secrets
+├── skills/                 # global skills pool (symlinked per agent)
+│   └── <skill-name>/
+│       └── SKILL.md
+└── agents/
+    └── <name>/
+        ├── start.sh        # launcher (sets env, execs claude)
+        ├── settings.json   # Claude Code settings
+        ├── .mcp.json       # MCP server config
+        ├── CLAUDE.md       # agent identity (never overwritten by reconcile)
+        ├── skills/         # symlinks to ~/.switchroom/skills/<name>/
+        ├── .claude/
+        │   └── agents/     # sub-agent definition files
+        └── telegram/
+            ├── history.db  # SQLite message buffer
+            └── access.json # per-agent access control
+```
+
+## Lifecycle
+
+1. `switchroom agent create <name>` — scaffold agent from switchroom.yaml
+2. `systemctl --user start switchroom-<name>` — start the process
+3. Claude Code boots, loads CLAUDE.md + skills + .mcp.json
+4. MCP servers connect (Hindsight, switchroom-telegram, others)
+5. Telegram plugin polls for messages
+6. User sends message → plugin fires `UserPromptSubmit` hook → Claude responds
+7. `switchroom agent reconcile <name>` — re-apply switchroom.yaml (no CLAUDE.md touch)
+
+## Deep dives
+
+- [cascade.md](cascade.md) — three-layer config cascade semantics
+- [sub-agents.md](sub-agents.md) — delegation patterns and model routing
+- [telegram.md](telegram.md) — enhanced Telegram plugin features

package/skills/switchroom-architecture/cascade.md

@@ -0,0 +1,112 @@
+# Config Cascade
+
+Switchroom resolves agent configuration through three layers applied bottom-up:
+
+```
+defaults:    ← global baseline
+  ↓
+profiles:    ← named presets (agent opts in with extends:)
+  ↓
+agents:      ← per-agent overrides (only express differences)
+```
+
+The resolved value at any field is determined by the **merge type** for that field.
+
+## Merge Types
+
+| Merge type | Fields | Behavior |
+|---|---|---|
+| **Union** | `tools.allow`, `tools.deny`, `skills` | Combine across all layers, dedup |
+| **Override** | `model`, `extends`, `dangerous_mode`, most scalars | Agent wins entirely |
+| **Per-key merge** | `mcp_servers`, `env`, `subagents` | Agent wins on key conflict, others preserved |
+| **Per-field merge** | `soul`, `memory`, `session`, `channels` | Agent wins per sub-field |
+| **Per-event concat** | `hooks` | Defaults appended first, then agent |
+| **Concatenate** | `schedule`, `system_prompt_append`, `claude_md_raw`, `cli_args` | Defaults prepended |
+| **Deep merge** | `settings_raw` | Recursive object merge, agent wins |
+
+## Examples
+
+### Tools union
+```yaml
+defaults:
+  tools:
+    allow: [all]
+
+profiles:
+  coder:
+    tools:
+      allow: [Bash, Read, Write, Edit]  # union: [all, Bash, Read, ...]
+
+agents:
+  dev:
+    extends: coder
+    tools:
+      deny: [WebSearch]                 # union: deny=[WebSearch]
+```
+
+### system_prompt_append concatenation
+```yaml
+defaults:
+  system_prompt_append: "Always respond concisely."
+
+profiles:
+  coder:
+    system_prompt_append: "Prefer TypeScript."
+
+agents:
+  dev:
+    extends: coder
+    system_prompt_append: "Never use `any`."
+```
+Resolved for dev:
+```
+Always respond concisely.
+Prefer TypeScript.
+Never use `any`.
+```
+
+### subagents per-key merge
+```yaml
+defaults:
+  subagents:
+    worker:
+      description: "Generic implementation"
+      model: sonnet
+
+agents:
+  dev:
+    subagents:
+      worker:
+        description: "Code implementation with tests"  # replaces default worker
+        model: sonnet
+        tools: [Read, Edit, Write, Bash]
+    # researcher and reviewer inherited from defaults unchanged
+```
+
+### hooks per-event concat
+```yaml
+defaults:
+  hooks:
+    PreToolUse:
+      - command: "/opt/audit.sh"
+
+agents:
+  dev:
+    hooks:
+      PreToolUse:
+        - command: "/opt/dev-extra-check.sh"
+# Resolved: audit.sh runs first, then dev-extra-check.sh
+```
+
+## Profile Resolution
+
+Profiles can be defined in two places (inline takes priority):
+
+1. **Inline** in `profiles:` section of switchroom.yaml
+2. **Filesystem** at `profiles/<name>/` — contains `CLAUDE.md.hbs`, `SOUL.md.hbs`, optional `skills/`
+
+An agent inherits from at most one profile via `extends: <name>`. Profiles themselves do not chain.
+
+## Vault references
+
+Secrets in switchroom.yaml use `vault:key-name` syntax. They're resolved at scaffold/reconcile time from `~/.switchroom/vault.enc`. Vault values are written into `start.sh` as environment variables — never stored in plaintext in switchroom.yaml.

package/skills/switchroom-architecture/sub-agents.md

@@ -0,0 +1,87 @@
+# Sub-Agent Delegation
+
+Switchroom generates Claude Code custom sub-agent files (`.claude/agents/<name>.md`) from `switchroom.yaml`. This enables the "Opus plans, Sonnet implements" pattern: the main agent delegates to cheaper models running in the background.
+
+## Default sub-agents
+
+Switchroom ships three default sub-agents that every agent inherits:
+
+| Sub-agent | Model | Purpose |
+|-----------|-------|---------|
+| **worker** | Sonnet | Implementation — writing, editing, building, testing |
+| **researcher** | Haiku | Exploration — codebase search, docs, investigation |
+| **reviewer** | Sonnet | Quality review — correctness, completeness, security |
+
+These are defined in `defaults.subagents` and flow through the cascade to every agent.
+
+## How delegation works
+
+1. Main agent (e.g. Opus) receives user request
+2. Dispatches to `@worker` — Sonnet running in background
+3. Main agent responds immediately ("on it") and stays available for new messages
+4. Worker implements in its own git worktree (if `isolation: worktree`)
+5. Worker reports back; main agent reviews and responds to user
+
+The user can override per-invocation: "use @worker but run it on opus for this one."
+
+## Configuration fields
+
+Each sub-agent supports the full Claude Code frontmatter spec:
+
+| Field | Description |
+|-------|-------------|
+| `description` | (required) When the main agent should delegate here |
+| `model` | `sonnet`, `opus`, `haiku`, full model ID, or `inherit` |
+| `background` | Run non-blocking. Default: false |
+| `isolation` | `worktree` — own git branch for file work |
+| `tools` | Tool allowlist (inherits all if omitted) |
+| `disallowedTools` | Tool denylist |
+| `maxTurns` | Auto-stop after N turns |
+| `permissionMode` | `default`, `acceptEdits`, `auto`, `bypassPermissions`, `plan` |
+| `effort` | `low`, `medium`, `high`, `max` |
+| `color` | Display color in task list |
+| `memory` | `user`, `project`, or `local` for persistent learning |
+| `skills` | Skills to preload |
+| `prompt` | System prompt (the markdown body of the sub-agent file) |
+
+## Cascade behavior
+
+Sub-agents are **per-key merged**. An agent overrides a specific sub-agent by declaring one with the same name:
+
+```yaml
+defaults:
+  subagents:
+    worker:
+      description: "Generic implementation"
+      model: sonnet
+
+agents:
+  dev:
+    subagents:
+      worker:
+        description: "Code implementation with test coverage"
+        model: sonnet
+        tools: [Read, Edit, Write, Bash, Grep, Glob]
+        prompt: "Always write tests. Run them before reporting done."
+      # researcher and reviewer inherited unchanged from defaults
+```
+
+## Model resolution order (highest wins)
+
+1. `CLAUDE_CODE_SUBAGENT_MODEL` env var — switchroom deliberately doesn't set this (it would override ALL sub-agents including Claude Code built-ins)
+2. Per-invocation `model` parameter (user/main-agent override)
+3. Sub-agent file's `model` frontmatter (what switchroom sets)
+4. Main conversation's model
+
+## Coexistence with Claude Code built-ins
+
+| Agent | Model | Origin |
+|-------|-------|--------|
+| Explore | Haiku | Claude Code built-in |
+| Plan | Inherit | Claude Code built-in |
+| general-purpose | Inherit | Claude Code built-in |
+| worker | Sonnet | Switchroom default |
+| researcher | Haiku | Switchroom default |
+| reviewer | Sonnet | Switchroom default |
+
+All sub-agents share the same `.claude/agents/` directory. Switchroom-generated files don't conflict with Claude Code's built-ins.