# Sessions, snapshots, and evidence

An Interceptor host process runs a target session and owns the local API used by
Operator. Keep that process alive through campaign finalization and collection.

## Start and verify

With a sealed and built blueprint and host credentials configured:

```sh
interceptor run --environment ./interceptor-environment \
  --model-provider openai-chat --provider-base-url https://api.openai.com/v1 \
  --provider-auth api-key-env --model-api-key-env TARGET_MODEL_KEY \
  --allow-model YOUR_TARGET_MODEL
```

Add separate embedding options from [setup](setup.md) when the application needs
them. Record the session ID and printed application URL. Non-HTTP interfaces expose
`POST /operations/<operation-id>` at that application URL; use the actual printed
port, not the separate Operator API address.

```sh
curl --fail-with-body -H 'Content-Type: application/json' \
  --data '{"message":"What is the status of order-456?"}' \
  http://PRINTED_APPLICATION_HOST_AND_PORT/operations/invoke
```

This request matches the support recipe's input contract; other agents have their
own operation/input shapes. Check application content and dependency observations,
not only HTTP success. Do not attach a probe campaign to the instance reserved for
Operator; restart after standalone verification to begin from fresh seed state.

## Inspect and export

From another terminal with the same data-directory setting:

```sh
interceptor list
interceptor status SESSION_ID --json
interceptor logs verify SESSION_ID
interceptor logs export SESSION_ID --output ./interceptor-evidence.tar
```

Use a new export path. Interceptor retains protected events, state journals, blobs,
checkpoints, operation receipts, and application stdout/stderr. Export each relevant
session in a restore lineage. Verification establishes integrity of available data,
not completeness or a successful security outcome.

## Collect native application logs

The support recipe writes `/state/support/logs/agent.log` in a mutable root. Collect
that file separately before purging. As the authorized local Docker administrator,
find the exact session container ID from Interceptor's host binding/status and
confirm it against the session and Docker daemon; do not select an unrelated
container by a guessed name. While that container remains available:

```sh
mkdir -p collected-native-logs
docker cp EXACT_SESSION_CONTAINER_ID:/state/support/logs/agent.log ./collected-native-logs/agent.log
```

Read the copied file and check that it contains the completed invocation's log
records. This is explicit administrator collection, not automatic campaign evidence.
Application stdout/stderr also remain under the session's native logs directory.

Live mutable roots can reside in session-owned Docker volumes; host staging folders
are not necessarily their current contents. If the container has been removed,
preserve the session and its volumes and follow the release's native state collection
procedure rather than guessing a volume or changing ownership. A verified snapshot
can retain declared file state when snapshots are supported. Do not assume the
ordinary logs export includes every arbitrary mutable file.

## Snapshots and restoration

For an unbound administrative session with snapshot support:

```sh
interceptor snapshot create SESSION_ID --name baseline --json
interceptor snapshot list SESSION_ID --json
interceptor snapshot inspect SESSION_ID CHECKPOINT_ID
```

Once bound to a campaign, use snapshot operations through Operator or the native API.
Restore is a lifecycle API operation, not an `interceptor restore` CLI command. It
returns a fresh native session ID and binding; use those for subsequent work.

Snapshots include declared logical state, managed services, and application context
explicitly serialized by configured hooks. They do not save process memory, open
connections, remote state, or Attack Harness's conversation. Check actual restored
behavior before advertising support. The basic support recipe leaves snapshots
disabled because its conversation state lives in memory.

## Stop without deleting evidence

```sh
interceptor stop SESSION_ID
```

Stopping retains evidence and leaves the API available until the owning `run`
process exits. Ctrl+C ends that host service and any remaining target. Confirm
Operator has finished first. Purge is a separate destructive action; export and
collect required files before using a narrowly selected purge command.

If evidence storage fails, preserve the diagnostic and original retained records.
Further turns or snapshots may be blocked. A response-recording failure can follow
a committed side effect; absence of a record does not prove rollback. Fix the
storage problem and prepare a fresh session rather than replaying uncertain work.
