Run learner code in a bounded local execution environment

[rosshd]

Parent: #56

Depends on: #53 and the activity-contract child of #56.

Blocks: the solution-evaluator child of #56.

Problem

The current drill checker executes learner Python in the main openLearn environment with pytest and no explicit wall-clock timeout.

An accidental infinite loop, memory blow-up, import side effect, filesystem write, environment read, or subprocess launch can hang or affect the learner's machine.

Issue #54 narrows tutor tool access, but learner-authored code still needs an execution boundary.

Goal

Add a bounded local code runner for interview activities, starting with Python, that limits damage, reports failures accurately, and works across supported platforms.

Runner contract

• Accept only a validated workspace, language adapter, problem interface, test bundle, and resource policy.
• Execute without shell interpolation.
• Use a scrubbed environment containing only required variables.
• Set an explicit working directory owned by the attempt.
• Enforce wall-clock timeout.
• Enforce CPU, memory, process-count, output-size, and file-size limits where the platform supports them.
• Disable network access when a reliable supported mechanism is available.
• Prevent reads and writes outside the owned workspace to the strongest practical degree on each platform.
• Capture stdout, stderr, exit status, signal or termination reason, duration, and resource-limit reason.
• Kill the process tree on cancellation or timeout.
• Keep runner failure distinct from compile, runtime, test, and learner-solution failure.

Platform strategy

• Define one shared runner result contract.
• Implement Python first.
• Use platform adapters where macOS, Linux, and Windows isolation primitives differ.
• Fail closed for a protection that the selected mode claims to provide.
• Document the actual security boundary and residual risks honestly.
• Provide a clearly labeled reduced-isolation fallback only when the learner explicitly opts in.

Test handling

• Keep hidden tests outside the learner-editable workspace where possible.
• Do not rewrite the learner's solution to enable tests.
• Mount or copy only the minimum problem harness required.
• Bound captured output so print loops cannot exhaust memory or terminal rendering.
• Make cancellation responsive from the CLI.

Acceptance criteria

• Infinite loops terminate within the configured wall-clock budget.
• Process trees are terminated on timeout and cancellation.
• Excessive output is truncated with an explicit result.
• Environment fixtures prove secret-like variables are unavailable.
• Workspace escape, subprocess, network, and resource-limit fixtures exercise the documented boundary on each supported platform.
• Unsupported protections are reported and never silently claimed.
• Hidden tests are not readable from the normal learner workspace under the documented mode.
• Runner infrastructure failures never count as incorrect learner answers.
• The existing trusted development test suite continues to run outside this runner.
• Python drill and /check behavior migrate without losing targeted feedback.
• make check passes on the supported OS matrix.

Escalation

• If strong local isolation cannot be implemented portably without a container or VM dependency, document the tradeoff and request a product decision before claiming sandbox security.
• Any default that executes with materially reduced isolation requires explicit product approval.

Out of scope

• Arbitrary package installation from learner code.
• General shell-command execution.
• Production malware analysis.
• Multi-language adapters beyond the initial Python runner.

[rosshd]

Board hygiene status: implementation is complete and validated on local main at a0ddce2, but that commit is not yet present on origin/main. Leaving this issue open until the local main branch is pushed; close it once the implementation is visible remotely.

[rosshd]

Manual test evidence - 2026-08-04 placement run

Tracked findings: MT-005, part of MT-006.

The learner completed the coding step before OpenLearn discovered that neither Docker nor Podman was available. After editor exit, secure execution failed and placement returned to the implementation prompt. Retrying reopened the same file and reproduced the same infrastructure failure.

Expected:

1. Preflight the selected secure runtime and pinned image before placement starts, or at latest before launching the editor.
2. If unavailable, explain the requirement and offer explicit choices: defer placement, continue with an honestly labeled unscored/reduced-isolation path if product-approved, or open setup help.
3. Do not make the learner repeat implementation to rediscover unchanged infrastructure state.
4. Preserve the source and mark the run as infrastructure-unavailable, never incorrect learner work.
5. openlearn doctor output and the placement prompt should agree on the exact recovery action.

Add a journey test where no OCI runtime exists and assert that the learner is warned before coding time is spent.

Classification: defect. Severity: high because a required dependency is discovered after the costly part of the flow.