solvewright 0.1.0__py3-none-any.whl

solvewright/cli.py

@@ -0,0 +1,263 @@
+"""`solvewright`: connect this computer to Interview Lab and serve its rounds.
+
+    solvewright               connect if needed, then wait for interview rounds
+    solvewright connect       approve this computer again (for example after a reset)
+    solvewright status        show the connection and the agents found here
+    solvewright disconnect    remove this computer from your account
+    solvewright doctor        check Python, Claude Code, Codex and the sandbox
+
+Nothing runs in the background: closing the window stops the connector.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import signal
+import sys
+import time
+import urllib.request
+import webbrowser
+from datetime import datetime
+from pathlib import Path
+
+from . import __version__, agents, connection, settings as settings_module, worker
+from .runtime import Runtime
+from .service import Service, ServiceError, Unavailable
+
+INSTRUCTIONS = Path(__file__).resolve().parent / "interviewer"
+ISOLATION_TEXT = {"sandbox": "sandboxed", "writes": "writes sandboxed, reads not limited",
+                  "no-commands": "no commands (sandbox unavailable here)"}
+
+
+class Out:
+    def __init__(self, stream=sys.stdout):
+        self.stream = stream
+        self.color = stream.isatty() and not os.environ.get("NO_COLOR") and os.environ.get("TERM") != "dumb"
+
+    def _wrap(self, code: str, text: str) -> str:
+        return f"\033[{code}m{text}\033[0m" if self.color else text
+
+    def bold(self, text: str) -> str:
+        return self._wrap("1", text)
+
+    def dim(self, text: str) -> str:
+        return self._wrap("2", text)
+
+    def good(self, text: str) -> str:
+        return self._wrap("32", text)
+
+    def warn(self, text: str) -> str:
+        return self._wrap("33", text)
+
+    def line(self, text: str = "") -> None:
+        print(text, file=self.stream, flush=True)
+
+    def row(self, label: str, value: str) -> None:
+        self.line("  " + self.dim(label.ljust(14)) + value)
+
+    def event(self, text: str) -> None:
+        self.line(self.dim(datetime.now().strftime("%H:%M")) + "  " + text)
+
+
+def pretty_path(path: Path) -> str:
+    try:
+        return "~/" + path.relative_to(Path.home()).as_posix()
+    except ValueError:
+        return str(path)
+
+
+def agent_rows(out: Out, described: dict) -> None:
+    for name, label in (("claude", "Claude Code"), ("codex", "Codex")):
+        info = described[name]
+        if info["available"]:
+            out.row(label, f"{info['version']} · {ISOLATION_TEXT.get(info['isolation'], info['isolation'])}")
+        else:
+            out.row(label, out.dim("not found"))
+
+
+def header(out: Out, config, label: str, described: dict, account: str | None = None) -> None:
+    out.line(out.bold("Solvewright connector") + " " + out.dim(__version__))
+    out.line()
+    out.row("This computer", f"{label} · {connection.operating_system()}")
+    if account:
+        out.row("Account", "@" + account)
+    agent_rows(out, described)
+    out.row("Interviews", pretty_path(config.interviews))
+    if not any(info["available"] for info in described.values()):
+        out.line()
+        out.line(out.warn("No Claude Code or Codex was found on this computer."))
+        out.line("Install one and sign in once in a terminal, then start the connector again:")
+        out.line("  Claude Code  https://code.claude.com/docs/en/setup")
+        out.line("  Codex        https://developers.openai.com/codex/cli")
+
+
+def approve(out: Out, config, service: Service, label: str, open_browser: bool) -> dict:
+    described = agents.describe()
+    details = {"connector": __version__, "os": connection.operating_system(),
+               "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)
+    code = pending["userCode"]
+    url = f"{config.site_url}/connect?code={code}"
+    out.line()
+    out.line("Approve this computer in your browser:")
+    out.line()
+    out.line("    " + out.bold(url))
+    out.line()
+    out.line("  Check that the page shows  " + out.bold(code))
+    out.line()
+    if open_browser:
+        try:
+            webbrowser.open(url)
+        except webbrowser.Error:
+            pass
+    shown = {"last": None}
+
+    def waiting(seconds_left: int) -> None:
+        minutes = seconds_left // 60
+        if shown["last"] != minutes:
+            shown["last"] = minutes
+            out.event(out.dim(f"Waiting for approval ({minutes + 1} min left). Ctrl+C cancels."))
+
+    reply = connection.wait(service, pending, on_wait=waiting)
+    record = connection.record(reply, config.service_url, label)
+    connection.save(config.connection_file, record)
+    out.line()
+    out.line(out.good("✓") + " Connected" + (f" to @{record['account']}" if record["account"] else "") + f" as “{label}”.")
+    return record
+
+
+def serve(out: Out, config, service: Service, record: dict) -> int:
+    runtime = Runtime(config.interviews, INSTRUCTIONS, config.home / "logs")
+    runtime.on_event = out.event
+    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()
+    out.event("Waiting for the Interview Lab")
+    if sys.platform == "win32":
+        def stop_on_break(_signal, _frame):
+            raise KeyboardInterrupt
+        signal.signal(signal.SIGBREAK, stop_on_break)
+    try:
+        worker.run(runtime, service, record, say=out.event)
+    except KeyboardInterrupt:
+        out.line()
+        out.line("Stopped. Nothing from Solvewright is running on this computer now.")
+        return 0
+    except worker.Revoked:
+        connection.forget(config.connection_file)
+        out.line()
+        out.line(out.warn("This computer was disconnected from your Solvewright account."))
+        out.line("Run `solvewright` again to connect it.")
+        return 2
+    except ServiceError as error:
+        out.line(out.warn(str(error)))
+        return 1
+    finally:
+        runtime.close()
+    return 0
+
+
+def start(out: Out, config, args) -> int:
+    service = Service(config.service_url, config.service_key)
+    label = (args.name or connection.computer_name()).strip()[:64]
+    record = connection.load(config.connection_file)
+    if record and record.get("service") != config.service_url:
+        record = None
+    described = agents.describe()
+    header(out, config, record["label"] if record and not args.name else label, described, record.get("account") if record else None)
+    if args.command == "connect" or not record:
+        if record:
+            try:
+                service.rpc("remove_interview_worker", {"p_worker_id": record["workerId"], "p_key": record["key"]})
+            except (OSError, ServiceError):
+                pass
+            connection.forget(config.connection_file)
+        try:
+            record = approve(out, config, service, label, not args.no_browser)
+        except KeyboardInterrupt:
+            out.line()
+            out.line("Cancelled. This computer was not connected.")
+            return 130
+        except connection.ApprovalDenied:
+            out.line(out.warn("The connection was declined in the browser. Nothing was saved."))
+            return 1
+        except connection.ApprovalExpired:
+            out.line(out.warn("The code expired. Run `solvewright` again for a new one."))
+            return 1
+        except (Unavailable, ServiceError) as error:
+            out.line(out.warn(str(error)))
+            return 1
+    return serve(out, config, service, record)
+
+
+def status(out: Out, config) -> int:
+    record = connection.load(config.connection_file)
+    header(out, config, record["label"] if record else connection.computer_name(), agents.describe(), record.get("account") if record else None)
+    out.line()
+    if record:
+        out.line(f"Connected since {record.get('connectedAt', 'an earlier session')}. Run `solvewright` to serve rounds.")
+    else:
+        out.line("Not connected. Run `solvewright` to approve this computer.")
+    return 0
+
+
+def disconnect(out: Out, config) -> int:
+    record = connection.load(config.connection_file)
+    if not record:
+        out.line("This computer is not connected.")
+        return 0
+    try:
+        Service(config.service_url, config.service_key).rpc("remove_interview_worker", {"p_worker_id": record["workerId"], "p_key": record["key"]})
+    except (OSError, ServiceError) as error:
+        out.line(out.warn(f"Could not reach Solvewright ({error}). Remove the computer from the Interview Lab page instead."))
+    connection.forget(config.connection_file)
+    out.line("Disconnected. Your interview files stay in " + pretty_path(config.interviews) + ".")
+    return 0
+
+
+def doctor(out: Out, config) -> int:
+    out.line(out.bold("Solvewright connector") + " " + out.dim(__version__))
+    out.line()
+    out.row("Python", sys.version.split()[0] + ("" if sys.version_info >= (3, 10) else out.warn("  needs 3.10 or newer")))
+    described = agents.describe(max_age=0)
+    agent_rows(out, described)
+    claude = agents.executable("claude")
+    if claude:
+        out.row("Claude flags", "ok" if agents.claude_supports_isolation(claude) else out.warn("too old: run `claude update`"))
+        out.row("Claude sandbox", "available" if agents.claude_can_sandbox() else out.warn(
+            "unavailable" + (" (install bubblewrap and socat)" if sys.platform.startswith("linux") else "")))
+    try:
+        with urllib.request.urlopen(config.site_url, timeout=10) as response:
+            out.row("Solvewright", "reachable" if response.status == 200 else f"HTTP {response.status}")
+    except OSError as error:
+        out.row("Solvewright", out.warn(f"unreachable ({error})"))
+    record = connection.load(config.connection_file)
+    out.row("Connection", f"@{record.get('account') or '?'} · {record['label']}" if record else "not connected")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="solvewright", description="Connect your own Claude Code or Codex to Solvewright Interview Lab.",
+                                     epilog="Source: https://github.com/fus3r/solvewright-connector")
+    parser.add_argument("command", nargs="?", default="start", choices=("start", "connect", "status", "disconnect", "doctor"))
+    parser.add_argument("--name", help="how this computer is named in your account")
+    parser.add_argument("--no-browser", action="store_true", help="print the approval link without opening a browser")
+    parser.add_argument("--home", help=argparse.SUPPRESS)
+    parser.add_argument("--version", action="version", version=f"solvewright {__version__}")
+    args = parser.parse_args(argv)
+    out = Out()
+    config = settings_module.load(args.home)
+    if args.command == "status":
+        return status(out, config)
+    if args.command == "disconnect":
+        return disconnect(out, config)
+    if args.command == "doctor":
+        return doctor(out, config)
+    return start(out, config, args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

solvewright/connection.py

@@ -0,0 +1,137 @@
+"""Approving this computer from the browser, and the key that approval yields.
+
+The flow is the one `gh auth login` uses: the terminal shows a short code, the
+person signed in to Solvewright confirms it on solvewright.app/connect, and
+only then does this computer receive its own key. The command line never
+carries a secret, and the key never leaves this machine; the service keeps a
+hash of it.
+"""
+from __future__ import annotations
+
+import json
+import os
+import platform
+import re
+import subprocess
+import sys
+import tempfile
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .service import Service, ServiceError, Unavailable
+
+FORMAT = "solvewright-connection-v1"
+
+
+class ApprovalDenied(Exception):
+    pass
+
+
+class ApprovalExpired(Exception):
+    pass
+
+
+def computer_name() -> str:
+    name = ""
+    if sys.platform == "darwin":
+        try:
+            name = subprocess.run(["scutil", "--get", "ComputerName"], capture_output=True, text=True, timeout=3).stdout
+        except (OSError, subprocess.SubprocessError):
+            name = ""
+    elif sys.platform == "win32":
+        name = os.environ.get("COMPUTERNAME", "")
+    name = name or platform.node()
+    name = re.sub(r"\.(local|lan|home)$", "", name.strip())
+    name = re.sub(r"[\x00-\x1f\x7f]", "", name)
+    return name[:64] or "This computer"
+
+
+def operating_system() -> str:
+    if sys.platform == "darwin":
+        return "macOS " + (platform.mac_ver()[0] or "").strip()
+    if sys.platform == "win32":
+        return "Windows " + platform.release()
+    try:
+        release = platform.freedesktop_os_release()
+        return release.get("PRETTY_NAME") or "Linux"
+    except (OSError, AttributeError):
+        return "Linux"
+
+
+def load(path: Path) -> dict | None:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    if not isinstance(data, dict) or data.get("format") != FORMAT:
+        return None
+    if not all(isinstance(data.get(field), str) and data[field] for field in ("workerId", "owner", "key", "service")):
+        return None
+    return data
+
+
+def save(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    handle, temporary = tempfile.mkstemp(prefix=".connection-", dir=path.parent)
+    try:
+        with os.fdopen(handle, "w", encoding="utf-8") as file:
+            json.dump({"format": FORMAT, **data}, file, indent=2)
+        os.chmod(temporary, 0o600)
+        os.replace(temporary, path)
+    except BaseException:
+        try:
+            os.unlink(temporary)
+        except OSError:
+            pass
+        raise
+
+
+def forget(path: Path) -> None:
+    try:
+        path.unlink()
+    except FileNotFoundError:
+        pass
+
+
+def request(service: Service, label: str, details: dict) -> dict:
+    reply = service.rpc("start_interview_connection", {"p_label": label, "p_details": details})
+    if not isinstance(reply, dict) or not all(isinstance(reply.get(key), str) for key in ("deviceCode", "userCode")):
+        raise ServiceError("Solvewright returned an incomplete connection request.")
+    return reply
+
+
+def wait(service: Service, pending: dict, on_wait=None, sleep=time.sleep, now=time.monotonic) -> dict:
+    """Poll until the browser approves or denies, or the code expires."""
+    interval = max(2, int(pending.get("interval") or 3))
+    deadline = now() + max(60, int(pending.get("expiresIn") or 600))
+    while now() < deadline:
+        try:
+            reply = service.rpc("poll_interview_connection", {"p_device_code": pending["deviceCode"]})
+        except Unavailable:
+            reply = {"status": "pending"}
+        status = reply.get("status") if isinstance(reply, dict) else None
+        if status == "approved":
+            if not all(isinstance(reply.get(key), str) and reply[key] for key in ("workerId", "owner", "key")):
+                raise ServiceError("Solvewright approved this computer but sent an incomplete key.")
+            return reply
+        if status == "denied":
+            raise ApprovalDenied()
+        if status == "expired":
+            raise ApprovalExpired()
+        if on_wait:
+            on_wait(max(0, int(deadline - now())))
+        sleep(interval)
+    raise ApprovalExpired()
+
+
+def record(reply: dict, service_url: str, label: str) -> dict:
+    return {
+        "service": service_url,
+        "workerId": reply["workerId"],
+        "owner": reply["owner"],
+        "key": reply["key"],
+        "account": reply.get("handle") or "",
+        "label": label,
+        "connectedAt": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+    }

solvewright/interviewer/cases/portals/brief.txt

@@ -0,0 +1,13 @@
+# Reusable portals — candidate brief
+
+This is a synthetic practice case inspired by a reported round at a quant firm (HRT or Jane Street). Its exact rules and datasets are invented for training.
+
+Nomads arrive with an origin and destination on a 2D plane. Walking a unit of Euclidean distance costs $1. You may construct reusable bidirectional portals. Constructing a portal from `a` to `b` costs `5 * distance(a, b)` once; traversing it is free.
+
+At each step you see the current origin–destination request and all earlier requests. Before that nomad travels, you may add zero or more portals whose endpoints are finite 2D coordinates within ±1,000,000 on each axis (a practical runner limit). Existing portals persist for the rest of the episode. You cannot move or remove them. A nomad takes the shortest route through any combination of walking and the portals built so far. Each trip is charged once at its arrival; later construction does not change an earlier trip's bill.
+
+Minimize the sum of construction and travel costs over the episode. The horizon is known. You do not see future evaluation requests. Eight complete **synthetic training episodes** are available in `data/portal-samples/`; you may inspect and plot them. Fresh evaluation episodes follow this mock's generator, not a claimed reconstruction of HRT's generator.
+
+For practical evaluation, the runner limits an episode to 24 portals and gives a submitted policy 10 seconds to answer each request on the local machine. The scorer and stream runner are provided; you are not required to implement the routing evaluator unless that is the selected task. Python's standard library is enough for a policy; exploration tools are optional.
+
+Begin by explaining what you would establish and implement before optimizing placement. There is no requirement to prove a globally optimal online policy.

solvewright/interviewer/cases/portals/interviewer.txt

@@ -0,0 +1,49 @@
+# Portal case — examiner only
+
+Read [reported-round.txt](reported-round.txt) for provenance and uncertainty. Show [brief.txt](brief.txt) at the start of the playable case. Do not present synthetic defaults as recovered historical details.
+
+## Contract and runner
+
+The brief fixes Euclidean walking, free teleportation, bidirectional reusable portals, endpoints within ±1,000,000 per axis, no deletion, current-request-before-travel construction, no retrospective savings, and no future observations. The training generator uses 96 arrivals per episode. The coordinate bound, 24-portal limit and 10-second per-response timeout are practical mock limits, not source facts. Candidate policies receive the horizon in every request.
+
+Keep `tools/portal_lab.py` examiner-only until the candidate has completed sample investigation: its source contains the synthetic distribution. The source generates origins in arrival order along a slowly drifting random walk and destinations around a translated, noisy copy. Both the law and this choice of interpretation are invented. It is an empirical optimization exercise, not an exact recreation. Eight shipped samples use fixed training seeds. For final evaluation, generate new seeds after the candidate freezes the policy. Report every tested episode, not just the best.
+
+Commands, run from the context/interviewer folder:
+
+```sh
+python3 tools/portal_lab.py self-test
+python3 tools/portal_lab.py samples --out data/portal-samples
+python3 tools/portal_lab.py generate --seed 9001 --out ../../.examiner/portal-eval-9001.json
+python3 tools/portal_lab.py score --episode data/portal-samples/sample-01.json
+python3 tools/portal_lab.py run --episode ../../.examiner/portal-eval-9001.json --policy /absolute/path/policy.py
+```
+
+Write generated evaluation episodes under `.examiner/`: the sandbox only allows writes inside the round folder. The policy protocol is newline-delimited JSON over stdin/stdout, one request and one response at a time. Input is `{"step":0,"horizon":96,"origin":[x,y],"destination":[x,y],"portals":[...]}`. Response is `{"build":[{"a":[x,y],"b":[x,y]}]}`; an empty list means no construction. Send debug logs to stderr. The runner launches the candidate Python file as a child, enforces protocol and sequential delivery, and calculates the routes; the child must not open the evaluation episode or generator files. This is a trust-based local protocol, not an adversarial sandbox.
+
+For offline scoring, a plan file is `[{"step":0,"a":[0,0],"b":[10,0]}, ...]`. `score --plan plan.json` replays the build schedule. This checks the objective, not whether the plan was generated without future access. Distinguish it from online policy evaluation.
+
+## Stages (release individually)
+
+**Clarify and baseline.** Ask the candidate to state the objective and what information the decision sees. Offer the no-portal scorer as infrastructure. If the round is specifically about routing, ask for a small correct fixed-network evaluator instead; reduce the later workload accordingly. Do not require both a full routing engine and a strong policy in a short mock.
+
+**Inspect samples.** Ask for the most useful first plot or summary, then let the candidate run it. Reward hypotheses supported by all samples and explicit uncertainty. Do not disclose the walk/copy structure in your questions. The original user already knows the reported walk premise, so record this case as `seen` unless a genuine transfer variant is used.
+
+**One usable policy.** Ask for a baseline placement policy and a measurable comparison against no portals. It need not be sophisticated. Freeze calibration/validation choices before tuning. Ask what evidence would justify a build's one-time cost. Implementation can use the supplied evaluator. Do not optimize on final-test seeds.
+
+**Online defense.** Ask the candidate to explain what happens at a late arrival or after demand changes. The online contract was visible from the start; do not “reveal” it now. Evaluate the cost of decisions at the time they were made.
+
+**One extension if time remains.** Choose one: buffer of four future requests; endpoint restrictions; construction coefficient changes from five to eight; abrupt change of destination regime; traversal charge; build only after the current trip. Disclose it as a new variant and agree on a baseline. Changing timing must also change the evaluator, so do not score an after-travel policy with the bundled before-travel runner.
+
+## Private checking notes / scoped reveal material
+
+For a fixed network of P portals, a complete walking graph over `s`, `t`, and all `2P` portal endpoints, plus zero-cost bidirectional edges for portal pairs, gives exact shortest travel distance. Dijkstra is enough. Comparing only “direct” and “one portal” is wrong when chains are allowed. Geometry can cross; there are no walls. The supplied evaluator recomputes this small graph per trip.
+
+With a single proposed portal of length L, a necessary aggregate benefit condition over the chosen trips is travel savings greater than `5L`; measure marginal savings against the existing network, not against direct walking, to avoid counting the same benefit twice. This is an offline benefit calculation, not by itself an online optimality proof. A policy may estimate future demand from training episodes or a recent window, but its assumptions and risk must be explicit. At the final request, no benefit can exceed L for a new portal of length L under these rules, so the factor-five construction charge cannot pay for itself on that request alone.
+
+Accept reasonable heuristics: representative endpoint pairs from recent requests, clustered demand, periodically evaluated builds, or another defensible scheme. The point is executable decisions and honest evaluation. Do not require the candidate to reproduce a preferred algorithm or infer the exact random generator.
+
+Hints, if requested, in order: (1) “What would the bill be with no construction?” (2) “Which part of the bill is paid once, and which is paid for each trip?” (3) a tiny repeated-request counterexample to per-nomad construction; (4) a marginal-savings equation or partial policy. Reveal only the obstacle requested.
+
+Score model quality and measured cost separately. Include no-portal cost, construction cost, travel cost, number of builds, and percent savings, which can be negative. Average across all held-out episodes. An offline comparator is a reference, not a known global optimum, unless proven.
+
+For an unseen transfer, change the mechanism materially: a one-way shortcut with a per-use toll, an online facility with maintenance, or a request buffer with a build delay. Update all relevant contract fields and evaluation; use a different case ID and mark `transfer`. Merely rotating the same points is `seen` practice.

solvewright/interviewer/cases/portals/reported-round.txt

@@ -0,0 +1,34 @@
+# Reported quant-firm round: reusable bidirectional portals
+
+Cleaned reconstruction of a candidate's account of a practical round at a quant firm (HRT or Jane Street). It describes the reported exercise only. No original statement, dataset, evaluator or submitted solution was available.
+
+## Reported setup
+
+A collection of nomads has starting and destination coordinates on a two-dimensional map. The candidate can place bidirectional portals to shorten journeys. Nomads take a shortest route using the portals made available to them.
+
+The stated economic tradeoff was approximately:
+
+- one dollar per unit of distance travelled by nomads;
+- five dollars per unit of distance between a portal's two ends.
+
+The candidate therefore needs to weigh construction cost against travel saved across multiple nomads. The recollection emphasizes reusable infrastructure rather than a separate portal for every traveller.
+
+Eight input samples could be inspected. They contained starting and destination positions, with no solution outputs. The reporting candidate was told that generated tests would follow the same distribution. AI tools were allowed.
+
+## Data exploration and the information-flow issue
+
+Plotting the samples suggested that points lay along a random walk. The relationship between nomad starts and ends on that walk was unusual and is not specified precisely in the account.
+
+The reporting candidate initially approached the problem as a general optimization problem, then tried to recover the walk's order geometrically: identify possible ends and approximate successive points by nearby positions. The account does not establish that this reconstruction was correct or necessary.
+
+Only after an implementation had been prepared did the interviewer reportedly clarify that inputs arrived sequentially, through a buffer, and that portal-placement decisions had to be made along the way. They further reported that points in generated tests arrived in the random walk's order. This made the arrival sequence directly useful, reducing the need to infer that order from the geometry alone.
+
+## What the account does not establish
+
+The exact distance metric; portal traversal cost; whether portals could be chained; legal endpoint locations; construction timing; whether old portals persisted; whether travellers were charged immediately or rerouted retrospectively; buffer size and lookahead; number of travellers; runtime and memory limits; the exact walk generator; scoring normalization; and total round duration were not supplied. It is also ambiguous whether “points” arriving online meant entire origin–destination requests or another representation of the walk.
+
+These gaps materially affect an implementation. They must be clarified rather than filled in as supposed historical facts. The playable mock in this folder fixes them as **synthetic exercise rules**.
+
+## What this supports practising
+
+The useful training target is a workflow: establish when information becomes available, implement and verify the objective, inspect sample structure, build a cheap baseline, compare empirical changes, and adapt a policy to sequential decisions. The source does not establish an official intended algorithm, a globally optimal solution, or how the firm scored the interview.