Move configuration to a YAML file, and make the tuning knobs configurable

The thresholds Part H says to tune on the real inference hardware were
hardcoded, so every adjustment would have been a PR. They now live in a
`tuning:` section of a YAML config file, which also replaces flat
environment variables as the home for structure (#32).

- The file (NISSE_CONFIG, default ./nisse-dev.yaml) carries structure
  and holds no secrets: credentials are ${VAR} references resolved from
  the environment, and a reference to an unset variable is an error
- The environment still wins: every existing NISSE_* variable overrides
  its key, and the file is optional, so .env and CI work unchanged
- Validation stays fail-fast and reports every problem at once; unknown
  keys are errors, so a misspelt knob fails at startup instead of
  silently doing nothing
- The config file joins the state store and .env in the check that
  refuses to start when they sit inside the workspace clone
- Tuning covers the executor's turn and failure limits, the consult
  budget, the delegation caps, the command timeout and the tool output
  limit, which Workspace now takes as a setting; the defaults are the
  values the agent already ran with
- llm.max_output_tokens reaches both LLM clients from the config

docs/Tuning-Guide.md explains the knobs for someone learning local
model tuning: how weights, quantization and the KV cache spend VRAM,
what each knob does and what goes wrong at either extreme, and an order
to tune in. nisse-dev.example.yaml documents every key and is checked
by a test so it cannot drift.

Closes #32

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

nisse-dev/src/nisse_dev/tools.py

@@ -86,13 +86,6 @@ EXECUTOR_TOOLS: list[dict[str, Any]] = [
 ]
 
 
-def _truncate(text: str) -> str:
-    if len(text) <= MAX_OUTPUT_CHARS:
-        return text
-    dropped = len(text) - MAX_OUTPUT_CHARS
-    return f"{text[:MAX_OUTPUT_CHARS]}\n[... {dropped} characters truncated]"
-
-
 def _child_env() -> dict[str, str]:
     """The project's build and test code is arbitrary; it has no business
     reading the agent's LiteLLM, Matrix, or Gitea credentials."""
@@ -106,10 +99,24 @@ class ToolOutcome:
 
 
 class Workspace:
-    def __init__(self, root: Path, *, timeout_s: int = DEFAULT_TIMEOUT_S) -> None:
+    def __init__(
+        self,
+        root: Path,
+        *,
+        timeout_s: int = DEFAULT_TIMEOUT_S,
+        max_output_chars: int = MAX_OUTPUT_CHARS,
+    ) -> None:
         self.root = Path(root)
         self.root.mkdir(parents=True, exist_ok=True)
         self._timeout_s = timeout_s
+        self._max_output_chars = max_output_chars
+
+    def _truncate(self, text: str) -> str:
+        limit = self._max_output_chars
+        if len(text) <= limit:
+            return text
+        dropped = len(text) - limit
+        return f"{text[:limit]}\n[... {dropped} characters truncated]"
 
     def _resolve(self, path: str) -> Path:
         candidate = Path(path)
@@ -142,7 +149,7 @@ class Workspace:
     def read_file(self, path: str) -> ToolOutcome:
         target = self._resolve(path)
         try:
-            return ToolOutcome(_truncate(target.read_text()), success=True)
+            return ToolOutcome(self._truncate(target.read_text()), success=True)
         except (OSError, UnicodeDecodeError) as exc:
             return ToolOutcome(f"could not read {path}: {exc}", success=False)
 
@@ -175,7 +182,9 @@ class Workspace:
             )
         except OSError as exc:
             return ToolOutcome(f"could not list {path}: {exc}", success=False)
-        return ToolOutcome(_truncate("\n".join(entries) or "(empty)"), success=True)
+        return ToolOutcome(
+            self._truncate("\n".join(entries) or "(empty)"), success=True
+        )
 
     def describe(self) -> str:
         """Told to the model, so it does not have to guess where it is."""
@@ -212,7 +221,7 @@ class Workspace:
                 f"command timed out after {self._timeout_s}s: {command}",
                 success=False,
             )
-        body = _truncate(
+        body = self._truncate(
             f"exit code: {process.returncode}\nstdout:\n{stdout}\nstderr:\n{stderr}"
         )
         return ToolOutcome(body, success=process.returncode == 0)