Harness Client

---
name: harness-client
description: 'Attaches to a running supervisor: shows what the factory does and records answers to its decisions. Use while a supervisor runs or a lane waits on a human judgment.'
---
<!-- Generated by `basicly skills-build` from skill.yaml. Do not edit; edit the source. -->

# Harness Client

This skill makes you a second session that attaches to a running supervisor, observes it and records human answers.
To drive work yourself, use `harness-loop`.

## Rules

- **IMPORTANT: never answer a decision for the human.** The engine queues only facts that recorded state cannot supply.
- **Record the human's answer word for word.** The lane's next dispatch is built from it.
- **Never take the lock from a live supervisor.** Two supervisors would land to the same base checkout.
- **Do not approve checkpoints, grant autonomy, land lanes or close issues.** Those stay with the session that drives the loop.
- **Poll no faster than the heartbeat.** A faster poll gives no newer state and loads the tracker.

## Attach

```sh
basicly loop session <root-issue>            # live status
basicly loop session <root-issue> --json     # machine-readable
```

Every command in this skill is a read or a write to one decision item, except the board's action route.
`loop session` reads the tracker and the supervisor lock and writes nothing. Any number of clients can attach.
It shows four things:

| Field | Meaning |
| --- | --- |
| supervisor | Who holds the lock and the age of its heartbeat. `(none running)` means nobody supervises the root. A stale heartbeat means the holder crashed. |
| lane | Each lane in flight, its worktree and branch, if the worktree exists, and its last run (agent, outcome, tokens). |
| decisions | How many judgments the session waits on. |
| grant | The autonomy level in force and the tokens spent against its budget. |

The exit status is 0 in all cases. For an exit code that means "blocked on a human", use `basicly loop decisions`.

## Answer a pending decision

```sh
basicly loop decisions <root-issue>                            # the queue; exits 1 when an item is pending
basicly loop watch <root-issue>                                # print new pending items
basicly loop watch <root-issue> --once                         # one pass, then exit
basicly loop answer <decision-id> "<answer>"                   # record one answer
basicly loop answer <decision-id> "<answer>" --by "<who>"      # attribute an answerer that is not a human
```

Show each item to the human as it is: the issue it blocks, its kind, the question and the lane's evidence.
The supervisor reads the answer on its next pass.

If no human is available, leave the item pending or delegate it:

```sh
basicly loop decide <decision-id> --root <root-issue>
```

The decider agent answers only from the session's intake corpus, with limited tools.
When the corpus has no answer, it gives the decision back to the human. That is the correct result. Do not retry it.

`loop watch --interval` defaults to the 15-second supervisor heartbeat.

## Lock takeover

While `loop session` shows a fresh heartbeat:

- do not start a second `basicly loop supervise`;
- do not run `basicly loop advance` on one of its lanes;
- do not delete or edit `.basicly/usage/supervisor.lock`.

Answer the pending decision instead. That unblocks the session.
When the heartbeat is stale, take over with a new supervisor. It claims the stale lock atomically:

```sh
basicly loop supervise <root-issue>
```

Do not delete the lock file by hand, because another contender can be in the middle of a takeover.

## Wall display

To show the board on a shared screen with `basicly board serve`, read [wall display](references/wall-display.md). Use `--no-actions` for a screen that anyone in the room can touch.