4. Launch Agent

agent_exit_code = await HARNESS_CLS().run(
    sb,
    workdir=md["workdir"],
    session_id=session_id,
    adapter_url=state.adapter_url,
    time_budget_sec=CONFIG.agent_time_budget_sec,
    prompt=swe.SWE_PROMPT,
)

await _sandbox.ensure_agent_user(sb, workdir)
ctx = HarnessContext(
    workdir=workdir,
    session_id=session_id,
    adapter_url=adapter_url,
)
await self.write_config(sb, ctx)
return await self.launch_and_wait(sb, ctx, prompt, time_budget_sec)

async def ensure_agent_user(sb: Sandbox, workdir: str) -> None:
    """Create the unprivileged 'agent' user that owns workdir + can git diff."""
    await sb.exec(
        f"id agent >/dev/null 2>&1 || useradd -m -s /bin/bash agent && "
        f"chown -R agent:agent /home/agent {workdir} && "
        f"git config --system --add safe.directory '*' && id agent",
        user="root",
        check=True,
        timeout=60,
    )

@dataclass(frozen=True)
class HarnessContext:
    """Generic run context, free of any task fields.

    model_label is the model name the harness advertises to its CLI. The slime
    adapter ignores it and serves whatever upstream sglang has loaded, so it is
    not a run() parameter.
    """

    workdir: str
    session_id: str
    adapter_url: str
    model_label: str = "slime-actor"

async def write_config(self, sb: Sandbox, ctx: HarnessContext) -> None:
    """Pre-ack bypass-permissions so claude-code starts headless."""
    settings = json.dumps({"hasCompletedOnboarding": True, "bypassPermissionsModeAccepted": True})
    await sb.exec(
        "mkdir -p /home/agent/.claude && "
        f"echo {shlex.quote(settings)} "
        "| tee /home/agent/.claude.json /home/agent/.claude/settings.json > /dev/null && "
        "chown -R agent:agent /home/agent/.claude /home/agent/.claude.json",
        user="root",
        check=True,
        timeout=60,
    )

async def launch_and_wait(self, sb: Sandbox, ctx: HarnessContext, prompt: str, time_budget_sec: int) -> int:
    cmd = f"/usr/local/bin/claude -p {shlex.quote(prompt)} {self.launch_flags}"
    extra = os.environ.get(self.extra_args_env, "").strip()
    if extra:
        cmd = f"{cmd} {extra}"
    env = {
        "ANTHROPIC_BASE_URL": ctx.adapter_url,
        "ANTHROPIC_AUTH_TOKEN": ctx.session_id,
        "ANTHROPIC_MODEL": ctx.model_label,
        **self.static_env,
    }
    extra_envs = os.environ.get(self.extra_envs_env, "").strip()
    if extra_envs:
        env.update(json.loads(extra_envs))
    return await run_agent(sb, workdir=ctx.workdir, start_cmd=cmd, env=env, time_budget_sec=time_budget_sec)

async def run_agent(sb: Sandbox, *, workdir: str, start_cmd: str, env: dict[str, str], time_budget_sec: int) -> int:
    """Launch the agent (start_cmd) and run it to completion, returning its exit code."""
    meta_dir = f"{workdir}/.harness"
    await sb.exec(f"mkdir -p {meta_dir} && chown agent:agent {meta_dir}", user="root", check=True, timeout=30)
    exit_code, _ = await exec_and_wait(
        sb,
        cmd=start_cmd,
        user="agent",
        env=env,
        workdir=workdir,
        out_file=f"{meta_dir}/trajectory.jsonl",
        time_budget_sec=time_budget_sec,
        tag="run",
        want_output=False,
    )
    return exit_code

diff_text = await swe.git_diff(sb, md["workdir"])

reward, applied_cleanly = await swe.run_evaluation(
    md,
    diff_text=diff_text,
    timeout_sec=CONFIG.eval_timeout_sec,
)