solvewright 0.1.0__tar.gz → 0.1.2__tar.gz

{solvewright-0.1.0 → solvewright-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: solvewright
-Version: 0.1.0
+Version: 0.1.2
 Summary: Connect your own Claude Code or Codex to Solvewright Interview Lab for mock technical interviews.
 Project-URL: Homepage, https://solvewright.app/coding/interviews
 Project-URL: Source, https://github.com/fus3r/solvewright-connector
@@ -44,8 +44,10 @@ then `solvewright`. Python 3.10 or newer. The package has no dependencies.
    line for each thing it does (a round prepared, a reply, tests recorded).
 4. Press Ctrl+C to stop. Nothing keeps running in the background, and nothing starts again by itself.
 
-Next time, `solvewright` reconnects without a new code. `solvewright disconnect` removes this
-computer from your account; you can also remove it from Interview Lab, which stops its key at once.
+Next time, run the same command again: it reconnects without a new code, and the terminal reminds you
+which command that is. `uvx` and `pipx run` keep the package in a cache and add no `solvewright`
+command to your shell, so with them, put `uvx` or `pipx run` in front of the commands below (for
+example `uvx solvewright status`). Removing this computer from Interview Lab stops its key at once.
 
 | Command | Does |
 | --- | --- |
@@ -67,8 +69,14 @@ stop the interviewer, and sync your history. There is no request that runs a com
   keeps a hash of it.
 - **It never sees your Claude or ChatGPT credentials.** It starts the official `claude` or `codex`
   program, unmodified, which signs in the way it always does. Usage counts against your own plan.
-- **It never runs your code.** Public tests run in your browser, in Pyodide (Python compiled to
-  WebAssembly). The connector only stores the files you tested and the result.
+- **It never runs your code.** Public tests and the interviewer's private checks run in your browser,
+  in Pyodide (Python compiled to WebAssembly); the page shows each check's label and result, never its
+  code. The connector only stores the files you tested and the results.
+- **It reports progress, not content.** While the interviewer works, the page learns which kind of
+  step it is on (reading your code, writing its notes, running its checks), never what it reads,
+  writes or says. It also passes on your plan's usage when the agent reports it (Codex's usage
+  windows, Claude Code's rate-limit events), read without a model call, so replies can use less
+  effort when your window is nearly spent.
 - **It does not update itself.** What runs is the version you installed from PyPI. The interviewer's
   instructions ship inside the package (`src/solvewright/interviewer/`), so you can read exactly what
   your agent is told.
@@ -81,7 +89,7 @@ It does that inside its own agent's sandbox, confined to the folder of the curre
 | | Commands | Files | Network |
 | --- | --- | --- | --- |
 | Claude Code, macOS and Linux | Claude Code's OS sandbox | Read and write only in the round folder; the rest of your home folder is unreadable | None |
-| Codex, macOS and Linux | Codex's sandbox with a Solvewright permission profile | Read and write in your interview folders; the rest of your home folder is unreadable | None |
+| Codex, macOS and Linux | Codex's sandbox with a Solvewright permission profile | Read and write in your interview folders; read the folders Codex itself is installed in; the rest of your home folder is unreadable | None |
 | Claude Code, native Windows | No command tool at all: its sandbox needs macOS, Linux or WSL2 | The file tools stay in the round folder | None |
 
 Claude Code runs with `--restricted --safe-mode --strict-mcp-config`: your own CLAUDE.md, hooks,

{solvewright-0.1.0 → solvewright-0.1.2}/README.md

@@ -21,8 +21,10 @@ then `solvewright`. Python 3.10 or newer. The package has no dependencies.
    line for each thing it does (a round prepared, a reply, tests recorded).
 4. Press Ctrl+C to stop. Nothing keeps running in the background, and nothing starts again by itself.
 
-Next time, `solvewright` reconnects without a new code. `solvewright disconnect` removes this
-computer from your account; you can also remove it from Interview Lab, which stops its key at once.
+Next time, run the same command again: it reconnects without a new code, and the terminal reminds you
+which command that is. `uvx` and `pipx run` keep the package in a cache and add no `solvewright`
+command to your shell, so with them, put `uvx` or `pipx run` in front of the commands below (for
+example `uvx solvewright status`). Removing this computer from Interview Lab stops its key at once.
 
 | Command | Does |
 | --- | --- |
@@ -44,8 +46,14 @@ stop the interviewer, and sync your history. There is no request that runs a com
   keeps a hash of it.
 - **It never sees your Claude or ChatGPT credentials.** It starts the official `claude` or `codex`
   program, unmodified, which signs in the way it always does. Usage counts against your own plan.
-- **It never runs your code.** Public tests run in your browser, in Pyodide (Python compiled to
-  WebAssembly). The connector only stores the files you tested and the result.
+- **It never runs your code.** Public tests and the interviewer's private checks run in your browser,
+  in Pyodide (Python compiled to WebAssembly); the page shows each check's label and result, never its
+  code. The connector only stores the files you tested and the results.
+- **It reports progress, not content.** While the interviewer works, the page learns which kind of
+  step it is on (reading your code, writing its notes, running its checks), never what it reads,
+  writes or says. It also passes on your plan's usage when the agent reports it (Codex's usage
+  windows, Claude Code's rate-limit events), read without a model call, so replies can use less
+  effort when your window is nearly spent.
 - **It does not update itself.** What runs is the version you installed from PyPI. The interviewer's
   instructions ship inside the package (`src/solvewright/interviewer/`), so you can read exactly what
   your agent is told.
@@ -58,7 +66,7 @@ It does that inside its own agent's sandbox, confined to the folder of the curre
 | | Commands | Files | Network |
 | --- | --- | --- | --- |
 | Claude Code, macOS and Linux | Claude Code's OS sandbox | Read and write only in the round folder; the rest of your home folder is unreadable | None |
-| Codex, macOS and Linux | Codex's sandbox with a Solvewright permission profile | Read and write in your interview folders; the rest of your home folder is unreadable | None |
+| Codex, macOS and Linux | Codex's sandbox with a Solvewright permission profile | Read and write in your interview folders; read the folders Codex itself is installed in; the rest of your home folder is unreadable | None |
 | Claude Code, native Windows | No command tool at all: its sandbox needs macOS, Linux or WSL2 | The file tools stay in the round folder | None |
 
 Claude Code runs with `--restricted --safe-mode --strict-mcp-config`: your own CLAUDE.md, hooks,

{solvewright-0.1.0 → solvewright-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "solvewright"
-version = "0.1.0"
+version = "0.1.2"
 description = "Connect your own Claude Code or Codex to Solvewright Interview Lab for mock technical interviews."
 readme = "README.md"
 license = "MIT"

{solvewright-0.1.0 → solvewright-0.1.2}/src/solvewright/__init__.py

@@ -1,3 +1,3 @@
 """Solvewright connector: runs your own Claude Code or Codex for Interview Lab."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"

solvewright-0.1.2/src/solvewright/activity.py

@@ -0,0 +1,180 @@
+"""What the examiner is doing during a turn, read from the agent's own event stream.
+
+The page shows it while the candidate waits. Only the kind of action and the
+folder it touches are kept: reading the brief, reading the candidate's code,
+writing private notes, running checks, writing the candidate's files. File
+contents, command text and the examiner's own words never leave this module,
+so nothing private (a reference, a later part) can reach the candidate.
+"""
+from __future__ import annotations
+
+import re
+import time
+from datetime import datetime, timezone
+
+# The steps each kind of turn is expected to pass through, in order.
+STEPS = {
+    "prepare": ("brief", "design", "reference", "checks", "files", "reply"),
+    "reply": ("read", "checks", "reply"),
+    "mark": ("read", "checks", "report", "reply"),
+}
+LINES = {
+    "brief": "Reading the brief and your past rounds",
+    "design": "Designing the problem",
+    "reference": "Writing a private reference solution",
+    "checks": "Running its checks",
+    "files": "Writing your files",
+    "read": "Reading your code",
+    "notes": "Updating its notes",
+    "report": "Writing your marks",
+    "reply": "Writing the reply",
+    "think": "Thinking it through",
+}
+FIRST_LINE = {"prepare": LINES["brief"], "reply": LINES["read"], "mark": LINES["read"]}
+
+RUNS_PYTHON = re.compile(r"(?:^|[\s;&|(`'\"/])(?:python(?:3(?:\.\d+)?)?|py|pytest|unittest)(?=$|[\s'\";)])")
+READS = re.compile(r"(?:^|[;&|]\s*|\n)\s*(?:cat|sed|head|tail|less|nl|rg|grep|ls|find|tree|wc|stat|diff|pwd)\b(?![^;&|\n]*>)")
+BRIEF = re.compile(r"(?:^|/)(?:history-context\.json|session-settings\.json|context/interviewer(?:/|$))")
+# Where a shell command writes: `> path`, `>> path`, `tee path`. Not 2>&1 or /dev/null.
+WRITES = re.compile(r"(?:(?<![0-9&])>{1,2}|\btee(?:\s+-a)?)\s*['\"]?([A-Za-z0-9_./-]+)")
+MENTIONS = re.compile(r"[A-Za-z0-9_./-]*(?:workspace/|\.examiner/|context/interviewer|history-context\.json|session-settings\.json)[A-Za-z0-9_./-]*")
+
+
+def stamp() -> str:
+    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def where(path: str, root: str = "") -> str:
+    """The part of the round a path belongs to: brief, workspace, report, private or other."""
+    path = str(path or "").replace("\\", "/")
+    root = str(root or "").replace("\\", "/").rstrip("/")
+    if root and path.startswith(root + "/"):
+        path = path[len(root) + 1:]
+    while path.startswith("./"):
+        path = path[2:]
+    if BRIEF.search(path):
+        return "brief"
+    if path.startswith("workspace/") or path == "workspace":
+        return "workspace"
+    if path.endswith(".examiner/report.json") or path == ".examiner/report.json":
+        return "report"
+    if path.startswith(".examiner/") or "/.examiner/" in path:
+        return "private"
+    return "other"
+
+
+Action = tuple[str, list[str], str]
+
+
+def command_actions(command: str, listed=()) -> list[Action]:
+    """What one shell command does, in order: reads, writes (by their targets), then a Python run.
+
+    Examiners write files with heredocs and scripts as often as with patch tools,
+    and read several files in one compound command, so the command's own text is
+    read for paths and redirections. Only their folders are kept.
+    """
+    command = str(command or "")
+    listed = [action for action in listed or [] if isinstance(action, dict)]
+    targets = [target for target in WRITES.findall(command) if target != "/dev/null"]
+    mentioned = [path for path in MENTIONS.findall(command) if path not in targets]
+    actions: list[Action] = []
+    if READS.search(command) or any(action.get("type") in ("read", "listFiles", "search") for action in listed):
+        actions.append(("read", [str(action.get("path") or "") for action in listed] + mentioned, command))
+    if targets:
+        actions.append(("write", targets, command))
+    if RUNS_PYTHON.search(command):
+        actions.append(("run", mentioned, command))
+    return actions
+
+
+def codex_action(item: dict) -> list[Action]:
+    """The actions in one Codex app-server ThreadItem; an empty list to ignore it."""
+    kind = item.get("type")
+    if kind == "reasoning":
+        return [("think", [], "")]
+    if kind == "agentMessage":
+        return [("answer", [], "")] if item.get("phase") == "final_answer" else []
+    if kind == "fileChange":
+        return [("write", [change.get("path", "") for change in item.get("changes") or [] if isinstance(change, dict)], "")]
+    if kind == "commandExecution":
+        return command_actions(item.get("command"), item.get("commandActions"))
+    return []
+
+
+def claude_action(block: dict) -> list[Action]:
+    """The actions in one content block of a Claude Code stream-json assistant event."""
+    kind = block.get("type")
+    if kind in ("thinking", "redacted_thinking"):
+        return [("think", [], "")]
+    if kind != "tool_use":
+        return []
+    name, given = block.get("name"), block.get("input") or {}
+    if name == "StructuredOutput":
+        return [("answer", [], "")]
+    if name in ("Write", "Edit", "MultiEdit", "NotebookEdit"):
+        return [("write", [str(given.get("file_path") or given.get("notebook_path") or "")], "")]
+    if name in ("Read", "Glob", "Grep", "LS"):
+        return [("read", [str(given.get("file_path") or given.get("path") or "")], "")]
+    if name == "Bash":
+        return command_actions(given.get("command"))
+    return []
+
+
+class TurnProgress:
+    """The steps of one turn as the page sees them: `state["turn"]`, and `state["activity"]` for older pages."""
+
+    def __init__(self, kind: str, state: dict, save, root: str = "", clock=time.monotonic, min_gap: float = 0.5):
+        self.kind, self.state, self.save, self.root, self.clock, self.min_gap = kind, state, save, root, clock, min_gap
+        self.data = {"kind": kind, "since": stamp(), "steps": [], "checks": 0}
+        self.last_save = None
+        state["turn"] = self.data
+        state["activity"] = FIRST_LINE[kind]
+
+    def step_for(self, action: str, places: set[str]) -> str | None:
+        if action == "answer":
+            return "reply"
+        if action == "run":
+            return "checks"
+        if action == "think":
+            # Before it has written anything, a preparing examiner is designing the problem.
+            return "design" if self.kind == "prepare" and not ({"reference", "files"} & self.seen()) else None
+        if action == "read":
+            if self.kind == "prepare":
+                return "brief" if ("brief" in places or not self.seen()) else None
+            return "read"
+        if action == "write":
+            if "report" in places:
+                return "report"
+            if "workspace" in places:
+                return "files"
+            if "private" in places:
+                return "reference" if self.kind == "prepare" else "notes"
+        return None
+
+    def seen(self) -> set[str]:
+        return {step["id"] for step in self.data["steps"]}
+
+    def observe(self, actions) -> None:
+        for action in actions or []:
+            self.observe_one(action)
+
+    def observe_one(self, action: Action) -> None:
+        kind, paths, _command = action
+        step = self.step_for(kind, {where(path, self.root) for path in paths})
+        if not step:
+            return
+        new = step not in self.seen()
+        if new:
+            self.data["steps"].append({"id": step, "at": stamp()})
+        if step == "checks":
+            self.data["checks"] += 1
+        line = LINES[step]
+        changed = new or line != self.state.get("activity") or step == "checks"
+        self.state["activity"] = line
+        now = self.clock()
+        if changed and (new or self.last_save is None or now - self.last_save >= self.min_gap):
+            self.last_save = now
+            self.save()
+
+    def finish(self) -> None:
+        self.state.pop("turn", None)

{solvewright-0.1.0 → solvewright-0.1.2}/src/solvewright/agents.py

@@ -173,7 +173,7 @@ def interrupt_process(process) -> None:
         process.terminate()
 
 
-def claude_command(binary: str, directory: Path, state: dict, sandbox: bool, read_roots: list[str]) -> list[str]:
+def claude_command(binary: str, directory: Path, state: dict, sandbox: bool, read_roots: list[str], effort: str | None = None) -> list[str]:
     command = [binary, "--print", "--output-format", "stream-json", "--verbose", "--json-schema", json.dumps(REPLY_SCHEMA),
                "--restricted", "--safe-mode", "--strict-mcp-config",
                "--permission-mode", "acceptEdits", "--permission-prompts", "none"]
@@ -190,7 +190,7 @@ def claude_command(binary: str, directory: Path, state: dict, sandbox: bool, rea
     model = state["settings"].get("model", "").strip()
     if model:
         command += ["--model", model]
-    effort = state["settings"].get("effort", "").strip()
+    effort = (state["settings"].get("effort", "") if effort is None else effort).strip()
     if effort:
         command += ["--effort", effort]
     return command
@@ -207,6 +207,27 @@ def claude_preamble(sandbox: bool) -> str:
             ".examiner/manifest.json that the reference was not executed, and say so when it matters.\n\n")
 
 
+def link_folders(path: Path, limit: int = 40) -> set[Path]:
+    """The folder of every symbolic link met while resolving `path`, one component at a time."""
+    folders: set[Path] = set()
+    pending = list(Path(os.path.abspath(path)).parts)
+    current = Path(pending.pop(0))
+    hops = 0
+    while pending and hops < limit:
+        candidate = current / pending.pop(0)
+        if candidate.is_symlink():
+            hops += 1
+            folders.add(candidate.parent)
+            target = Path(os.readlink(candidate))
+            if target.is_absolute():
+                current, pending = Path(target.parts[0]), list(target.parts[1:]) + pending
+            else:
+                pending = list(target.parts) + pending
+        else:
+            current = candidate
+    return folders
+
+
 class CodexClient:
     """Newline JSON-RPC client for Codex's documented app-server, isolated."""
 
@@ -218,6 +239,10 @@ class CodexClient:
         self.lock = threading.Lock()
         self.condition = threading.Condition()
         self.pending, self.finished, self.messages = {}, {}, {}
+        # Per thread: what the examiner starts doing, for the page's progress line. Never its content.
+        self.watchers: dict = {}
+        self.limits: dict | None = None
+        self.limits_at = 0.0
         self.sequence = 0
         self.loaded: set[str] = set()
         self.closed = threading.Event()
@@ -271,7 +296,12 @@ class CodexClient:
             if parent.resolve().is_relative_to(home):
                 # The release folder, e.g. ~/.codex/packages/standalone/releases/<version>/.
                 roots.append(str(parent.parent.resolve() if parent.name == "bin" else parent.resolve()))
-        return roots
+        # Codex starts itself again inside the sandbox (to load a resumed thread's instructions), so every link on
+        # the way to the binary must be readable too: ~/.local/bin/codex -> .../standalone/current/bin/codex, and
+        # `current` -> releases/<version>. Without the folder holding `current`, resuming a round after the
+        # connector restarts fails with "execvp() ... Operation not permitted".
+        roots += [str(folder) for folder in link_folders(Path(self.binary)) if folder.resolve().is_relative_to(home)]
+        return sorted(set(roots))
 
     def _launch(self, overrides: list[str]) -> None:
         self.closed.clear()
@@ -340,6 +370,18 @@ class CodexClient:
                     elif "id" in data and "method" in data:
                         # No approval is ever granted on the person's behalf.
                         self.send({"id": data["id"], "error": {"code": -32601, "message": "Approval is unavailable in Interview Lab."}})
+                    elif data.get("method") == "item/started":
+                        params = data["params"]
+                        watcher = self.watchers.get(params.get("threadId"))
+                        if watcher:
+                            try:
+                                watcher(params.get("item") or {})
+                            except Exception:  # A progress line must never break the turn.
+                                pass
+                    elif data.get("method") == "account/rateLimits/updated":
+                        snapshot = (data.get("params") or {}).get("rateLimits")
+                        if isinstance(snapshot, dict):
+                            self.limits, self.limits_at = snapshot, time.monotonic()
                     elif data.get("method") == "item/completed":
                         params = data["params"]
                         item = params.get("item", {})
@@ -379,7 +421,19 @@ class CodexClient:
         params["sandbox"] = "workspace-write"
         return self.rpc("thread/start", params)["thread"]["id"]
 
-    def turn(self, state: dict, directory: Path, prompt: str, callback, cancelled=None) -> dict:
+    def rate_limits(self, max_age: float = 60) -> dict | None:
+        """The account's Codex usage windows (5-hour and weekly), read without a model call."""
+        if self.limits is not None and time.monotonic() - self.limits_at < max_age:
+            return self.limits
+        try:
+            snapshot = self.rpc("account/rateLimits/read", {}, timeout=10).get("rateLimits")
+        except (ValueError, OSError):
+            return self.limits
+        if isinstance(snapshot, dict):
+            self.limits, self.limits_at = snapshot, time.monotonic()
+        return self.limits
+
+    def turn(self, state: dict, directory: Path, prompt: str, callback, cancelled=None, effort=None, watch=None) -> dict:
         if cancelled and cancelled.is_set():
             raise ValueError("The interviewer turn was stopped. Send a message to continue.")
         model = state["settings"].get("model", "").strip()
@@ -398,24 +452,29 @@ class CodexClient:
             raise ValueError("The interviewer turn was stopped. Send a message to continue.")
         params = {"threadId": thread, "cwd": str(directory), "input": [{"type": "text", "text": prompt}],
                   "outputSchema": REPLY_SCHEMA, "approvalPolicy": "never"}
-        effort = state["settings"].get("effort", "").strip()
+        effort = (state["settings"].get("effort", "") if effort is None else effort).strip()
         if effort:
             params["effort"] = effort
         if not self.profile:
             params["sandboxPolicy"] = {"type": "workspaceWrite", "writableRoots": [str(directory)], "networkAccess": False}
-        started = self.rpc("turn/start", params)
-        turn = started["turn"]["id"]
-        state["activeTurn"] = turn
-        callback()
-        if cancelled and cancelled.is_set():
-            self.interrupt(state)
-        key = (thread, turn)
-        with self.condition:
-            while key not in self.finished:
-                if self.closed.is_set() or self.process.poll() is not None:
-                    raise ValueError("Codex stopped. Send another message to resume this round.")
-                self.condition.wait(timeout=5)
-            completed = self.finished.pop(key)
+        if watch:
+            self.watchers[thread] = watch
+        try:
+            started = self.rpc("turn/start", params)
+            turn = started["turn"]["id"]
+            state["activeTurn"] = turn
+            callback()
+            if cancelled and cancelled.is_set():
+                self.interrupt(state)
+            key = (thread, turn)
+            with self.condition:
+                while key not in self.finished:
+                    if self.closed.is_set() or self.process.poll() is not None:
+                        raise ValueError("Codex stopped. Send another message to resume this round.")
+                    self.condition.wait(timeout=5)
+                completed = self.finished.pop(key)
+        finally:
+            self.watchers.pop(thread, None)
         if completed["status"] != "completed":
             error = completed.get("error") or {}
             raise ValueError(error.get("message", f"Codex turn {completed['status']}. Your files and conversation were kept."))

{solvewright-0.1.0 → solvewright-0.1.2}/src/solvewright/cli.py

@@ -93,7 +93,7 @@ def header(out: Out, config, label: str, described: dict, account: str | None =
 
 def approve(out: Out, config, service: Service, label: str, open_browser: bool) -> dict:
     described = agents.describe()
-    details = {"connector": __version__, "os": connection.operating_system(),
+    details = {"connector": __version__, "os": connection.operating_system(), "launcher": connection.launcher(),
                "python": ".".join(str(part) for part in sys.version_info[:3]),
                "agents": {name: info["version"] for name, info in described.items() if info["available"]}}
     pending = connection.request(service, label, details)
@@ -133,7 +133,7 @@ def serve(out: Out, config, service: Service, record: dict) -> int:
     out.line()
     out.line("Interview Lab is ready: " + out.bold(f"{config.site_url}/coding/interviews"))
     out.line("Keep this window open while you practise. Closing it stops the connector;")
-    out.line("nothing keeps running in the background.")
+    out.line("nothing keeps running in the background. Next time, run " + out.bold(connection.next_command()) + ": no new code is needed.")
     out.line()
     out.event("Waiting for the Interview Lab")
     if sys.platform == "win32":

{solvewright-0.1.0 → solvewright-0.1.2}/src/solvewright/connection.py

@@ -12,6 +12,7 @@ import json
 import os
 import platform
 import re
+import shutil
 import subprocess
 import sys
 import tempfile
@@ -47,6 +48,32 @@ def computer_name() -> str:
     return name[:64] or "This computer"
 
 
+def launcher() -> str:
+    """How this copy was started, so the terminal and Interview Lab can say what to run next time.
+
+    uvx and pipx run keep the package in a cache and put no command on the PATH, which is why
+    a plain `solvewright` would not be found afterwards."""
+    prefix = Path(sys.prefix).as_posix().lower()
+    if "/uv/" in prefix and "/archive-v" in prefix:
+        return "uvx"
+    # `pipx run` keeps throwaway environments in a cache whose place changed between pipx versions;
+    # `pipx install` keeps them under venvs/ and puts the command on the PATH.
+    if "/pipx/" in prefix and "/venvs/" not in prefix:
+        return "pipx"
+    return "command" if shutil.which("solvewright") else "module"
+
+
+def next_command(kind: str | None = None) -> str:
+    kind = kind or launcher()
+    if kind == "uvx":
+        return "uvx solvewright"
+    if kind == "pipx":
+        return "pipx run solvewright"
+    if kind == "command":
+        return "solvewright"
+    return ("py" if sys.platform == "win32" else "python3") + " -m solvewright"
+
+
 def operating_system() -> str:
     if sys.platform == "darwin":
         return "macOS " + (platform.mac_ver()[0] or "").strip()

{solvewright-0.1.0 → solvewright-0.1.2}/src/solvewright/interviewer/interviewer.txt

@@ -13,7 +13,7 @@ This folder is portable instruction material. Use it in the candidate's chosen a
 
 Honor settings already supplied. Defaults: **hybrid track, realistic mock, 50 minutes, English, Python, standard difficulty, AI off for the candidate**. Offer 45–60-minute mocks, 10–25-minute drills, and untimed coaching. Infer the programming language from existing code when appropriate.
 
-If the user says “start,” begin with these defaults. If the request is substantially unclear, ask at most two short setup questions together. Do not require a diagnostic before every mock. State the chosen settings briefly, mention `hint`, `skip`, `reveal this part`, and `end`, then give only the current prompt.
+If the user says “start,” begin with these defaults. If the request is substantially unclear, ask at most two short setup questions together. Do not require a diagnostic before every mock. Open with the current prompt itself: its first words are the problem. In the live runtime the page already shows the settings, the clock and the `hint`, `skip`, `reveal this part` and `end` controls, so do not restate them. In a standalone session, follow the prompt with one short line naming the settings and those four commands.
 
 Read [references/scoring.txt](references/scoring.txt). If the candidate supplies history or a history path, read it before choosing a case; otherwise start with unknown levels. Do not search unrelated personal files for history. A plain “I practised before” is not performance evidence.
 
@@ -59,6 +59,8 @@ New stages may deliberately change a requirement. Say “new requirement,” pre
 
 Keep ordinary turns short, usually under 180 words excluding a necessary prompt or data. Let the candidate submit full code or a longer explanation. Do not answer your own question, add leading examples after it, or praise vague statements as demonstrated insight.
 
+**A passing submission ends the part.** When the candidate's code meets the current part's contract (your checks pass and nothing in the contract is violated), accept it in a sentence or two and move on: release the next part, or, after the last part or in a drill, close the round with the report. Do not ask the candidate to explain or justify code that already works; working, tested code is the evidence for implementation and validation. Ask one short question only when the evidence cannot settle a mark you must give (for example, code that passes but whose approach you cannot tell from reading it), and say plainly that the candidate may skip it. Leave communication unmarked rather than demand an explanation.
+
 For an error, first locate a concrete contradiction or a small counterexample; ask the candidate to reason through it. Do not reject correct boolean-only code because a hypothetical future device might have more states. Classify issues as **required for this contract**, **optional improvement**, or **outside this round**. Spend time on material behavior, not naming, design-pattern compliance, or imaginary production risks.
 
 Accept a simple scan when sizes make it sufficient. Ask about scale only when scale is part of the active task. An executable design round should reach code and behavior; do not let it dissolve into a survey of distributed-system components.
@@ -94,9 +96,9 @@ Protect temporal boundaries. Training samples may be inspected completely. Durin
 
 ## Timing and stages
 
-For a 50-minute mock, aim for roughly 5 minutes of clarification, 10 of a baseline/design, 20 of coding or investigation, 10 of an extension, and 5 of a defense. These are budget guides, not a script. Reach a usable baseline before chasing sophistication. A 15-minute drill should contain one task, a real check, and a short debrief.
+For a 50-minute mock, aim for roughly 5 minutes of clarification, 10 of a baseline/design, 20 of coding or investigation, 10 of an extension, and 5 of a defense: one short, optional question about a tradeoff or a limit, asked only with time left. These are budget guides, not a script. Reach a usable baseline before chasing sophistication. A 15-minute drill should contain one task, a real check, and a short debrief.
 
-Use actual timestamps only when available. Do not treat every chat turn as a fixed number of minutes. If real timing is unavailable, use milestone pacing and say timing is approximate. Pauses and tool waits need not count as candidate work. At the limit, stop adding requirements, accept the current artifact, and debrief. Do not make completion depend on “mastering everything.”
+Use actual timestamps only when available. Do not treat every chat turn as a fixed number of minutes. If real timing is unavailable, use milestone pacing and say timing is approximate. Pauses and tool waits need not count as candidate work. In the live runtime, each message states the candidate's active time so far with your working time left out, because the page pauses their clock while you work; use that figure for pacing and in the report. At the limit, stop adding requirements, accept the current artifact, and debrief. Do not make completion depend on “mastering everything.”
 
 In mock mode, keep evaluative feedback for the end unless needed to disambiguate the interface or prevent work under a mistaken rule. In coached mode, explain briefly after an attempt and then check transfer with a different example. Never grade immediate repetition of a revealed answer as independent mastery.
 

{solvewright-0.1.0 → solvewright-0.1.2}/src/solvewright/interviewer/references/case-generation.txt

@@ -43,6 +43,10 @@ workspace/                 only candidate-visible files
 
 Create `.examiner/manifest.json` with `title`, `caseFamily`, `concepts` (a short string list), `mechanism`, the fixed `contract`, stage plan, and validation commands/results. Maintain it as the round evolves. For Python, put the candidate's initial implementation skeleton in `workspace/solution.py` and unittest checks in `workspace/tests/test_public.py`. **Run tests executes in the candidate's browser**, under Pyodide (CPython compiled to WebAssembly), with pytest collecting `workspace/tests/test_*.py` from the `workspace/` directory, so `import solution` works. Public tests must therefore use only the standard library, plus numpy when the task needs it; no threads, subprocesses, sockets, network, wall-clock timing or files outside `workspace/`. Verify your reference and the public tests yourself with the local Python before publishing, under the same constraints. For pseudocode, use `workspace/solution.txt`, give a precise callable/operation contract and hand-trace examples, and do not pretend executable tests have run. Additional candidate data/notes may be created there. Do not put solutions, future-stage prompts, private datasets or an answer-bearing test name in candidate files.
 
+**Private checks the page can run.** Besides the public tests, write private checks in `.examiner/checks/` (`test_*.py`, pytest or unittest, importing from `solution`) and `.examiner/checks/checks.json` with `{"checks": [{"id": "test_file.py::test_name", "part": 1, "label": "...", "note": "..."}]}`. The page runs them in the candidate's browser under Pyodide when they submit, so they follow the public tests' constraints and must not import your reference: put expected values in the checks themselves. The candidate sees each label (a plain name of the case, such as "cancel releases the cash") and, when a check fails, its note (one sentence that points at the case without giving the fix); never the check's code or expected values. Verify them on your reference and on one plausible wrong solution. When you release a later part, add its checks the same way.
+
+**Keep later turns to one step.** The candidate's clock is paused while you work, and every step spends the candidate's own plan. Each later message arrives with the changes to the candidate's files since your last reply and the latest results of the public tests and your private checks, run in the browser. Reply from them. Run code yourself only for evidence the checks cannot give. Do not list or re-read unchanged files, re-read these instructions, or write checkpoints, hashes or review logs: the runtime snapshots every message's files and results.
+
 The first turn should produce and validate the setup, then ask only the opening task. Later turns read candidate files from `workspace/` and test evidence from `.examiner/test-runs.json`. Use `.examiner/progress.json` for hints/reveals and continuity if needed. The runtime saves the chat and snapshots; do not ask the candidate to copy/import JSON.
 
 At the end write `.examiner/report.json` in the exact `interview-lab-session-v1` format from [session-format.txt](session-format.txt). Use the runtime's session ID and starting timestamp supplied in settings. Score with [scoring.txt](scoring.txt); leave unobserved dimensions null. Never fabricate elapsed active time. The runtime will save and display the report automatically.