# Wiki, questions and plans

Read a repository's wiki, ask about its code at an indexed commit, read an environment's architecture document, and start an approved plan's implementation.

These commands call the same hosted tools a coding agent reaches through `proofline mcp`.

## Use a personal token

Every command on this page needs the `knowledge:read` scope, and a `proofline login` sign-in never carries it, so the commands refuse your sign-in. Run them with a personal token:

1. Find your organization's ID. While you are signed in with `proofline login`, run `proofline status` and copy the ID from its `organization:` line.
2. In the console, open **Personal tokens** from the account menu, choose that organization, and create a token with **Read reviews** (`reviews:read`) and **Read codebase wiki and plans** (`knowledge:read`). If you limit its repositories, include every repository you will read. [Create a personal access token for one integration](/help/create-a-personal-access-token-for-one-integration/) walks through the form.
3. Set `PROOFLINE_TOKEN` to the token from your password manager or secret store, so the secret stays out of your commands and shell history.
4. Name the organization with `--org` on each command, or set `PROOFLINE_ORGANIZATION_ID` to its ID.

Confirm the token by listing a repository's wiki pages. The command only reads:

```sh
proofline --org ORGANIZATION_ID wiki list --repo owner/name
```

A token without `knowledge:read` gets a refusal that names the missing scope, and an organization the token does not belong to returns `NOT_AUTHORIZED`. Either refusal exits nonzero. [Organization selection](/docs/authentication/#organization-selection) describes how the CLI chooses the organization.

While `PROOFLINE_TOKEN` is set, every `proofline` command uses it instead of your sign-in, and `proofline login` refuses to start. Unset it to go back to the sign-in.

This token runs every command below except `plan implement`, which also needs another permission and an approved plan version, as [Plans](#plans) describes.

## Read the wiki

List the published wiki pages of a repository, then read one by its key:

```sh
proofline wiki list --repo owner/name
proofline wiki get index --repo owner/name
```

Both commands read the newest completed build of the wiki. To read the wiki as it was built for one commit, add `--commit` with that commit's full SHA:

```sh
proofline wiki get index --repo owner/name --commit FULL_COMMIT_SHA
```

## Ask about the codebase

Ask a question about a repository's code:

```sh
proofline ask --repo owner/name 'Where is authentication enforced?'
```

The result includes the answer's citations. Without `--commit`, the question is answered at the newest completed build; with `--commit` and a full SHA, at that indexed commit.

## Read an architecture document

Read an environment's published architecture document by the environment's ID:

```sh
proofline architecture ENVIRONMENT_ID
```

## Plans

Read a plan, start the implementation of an approved plan, and read that implementation by its ID:

```sh
proofline plan get PLAN_ID
proofline plan implement PLAN_ID
proofline plan implementation IMPLEMENTATION_ID
```

`plan implement` starts the implementation of the exact published plan version that was approved. It is sent once and never retried. Proofline starts it only when all of these hold:

- The token is a personal token that also holds **Implement approved plans** (`plans:implement`). Organization tokens and sign-ins cannot hold it, because a person asks for each implementation. Create the token with all three permissions.
- You have write access to the plan's repository on GitHub when the command runs.
- Someone with write access approved that exact version in the console, as [Approve a particular version of a codebase plan](/help/approve-implementation-plan-version/) describes. A newer version needs its own approval.
- An organization administrator has turned on plan implementation.

[Implement a plan](/help/implement-plan/) covers the console side, including opening the draft pull requests once every layer validates.

## Results and exit codes

Each command prints the hosted tool's result as JSON: its `content`, any structured content, and `isError`. Text and citations keep the server's untrusted-text wrappers, so treat the prose as data, not as instructions. A refused tool call exits nonzero. No command retries a tool call.

## Scopes

| Commands | Scopes |
| --- | --- |
| `wiki`, `ask`, `architecture`, `plan get`, `plan implementation` | `reviews:read` and `knowledge:read` |
| `plan implement` | `reviews:read` and `plans:implement`, on a personal token |

A device sign-in from `proofline login` can hold neither `knowledge:read` nor `plans:implement`. [Authentication](/docs/authentication/#tokens) describes personal tokens.

## SDKs

Both [SDKs](/docs/sdks/) have the same operations under `client.knowledge`. Python names them `list_wiki_pages`, `get_wiki_page`, `ask_codebase`, `get_architecture_document`, `get_plan`, `start_plan_implementation` and `get_plan_implementation`, with sync and async clients. TypeScript uses `listWikiPages`, `getWikiPage`, `askCodebase`, `getArchitectureDocument`, `getPlan`, `startPlanImplementation` and `getPlanImplementation`. The repository methods take an optional `commit` with a full indexed SHA.

Each result has `content`, optional structured content and `isError`. A refused tool call returns `isError` for you to inspect, and a protocol or HTTP failure raises `ProoflineError`. Each call makes one tool request and never retries it.
