# Pine 0.6.1: five recorded workflows

[Back to Pine](https://pine-pi.vercel.app/index.html)

These five recordings run Pine 0.6.1 with real Pi 1.4.0, herdr 0.9.5,
Pine's renderer and disposable project files on Linux. Only the model
responses are scripted, with a 0.18-second response delay. Commands,
saved agents, feedback checks, browser interactions and the generated
app's local smoke checks run for real.

**Waits are shortened.** The terminal streams keep their recorded output
in order while long waits and repeated spinner ticks move faster. The page
plays at 1.1× speed. Displayed process timers still show the original run's
time; they do not become a prediction of model speed. A successful scripted
trial demonstrates the workflow, not general agent quality.

Each topic has its own complete recording. The terminal is captured at
96 columns by 28 rows, with native herdr pane borders enabled from startup,
and fits inside the desktop frame at 15–16px.
There is no camera crop or sideways pan. On a phone, the whole recording
fits inline beneath its topic; the captions and this walkthrough describe
what happens. Reduced-motion mode starts with a still and requires a Play
action. Playback, pause and the timeline remain available.

## Widgets

The project already contains a note titled **Delivery promise**:
**Retries preserve the original delivery ID.** In a clear Pi conversation:

```text
/pine open notes
```

Pine opens the real notes pane below the conversation. The selected note,
its text and the pane's actions are all visible. Pi remains ready above
it. The captured session lasts 1.436 seconds; the delivered recording lasts
1.432 seconds, and the note appears at 00:00.519.

A note card on the page appears at that same playback cue. It is a page
illustration: playing the recording does not create or edit a note on the
visitor's computer. **Revert** hides the card and remembers that choice
for the browser session. Reduced motion keeps this page effect off.

## Build

The project contains `notes.txt`: delivery retries preserve the original
delivery ID, and the retry count has not yet been specified.

Typed in the parent Pi conversation:

```text
/pine new agent Review delivery notes. --kind review --model p03/scripted --name release-reader --access read-only
```

The command names the review kind, local scripted model and read-only access.
Confirm the access and review the saved-agent plan.
The separate builder saves the executable, checks startup and runs a
bounded trial. The parent reports the current step once. The result names
`./agents/release-reader`, the trial result, and the workspace and pane.
The agent opens in its own conversation, ready for a new request.

| Recording time | What appears |
| --- | --- |
| 00:00 | Choose access and review the plan. |
| 00:01.880 | The parent follows the separate builder's progress. |
| 00:02.588 | Pine saves the executable and checks startup. |
| 00:03.277 | The saved agent runs its bounded trial. |
| 00:05.379 | The parent names the saved path and trial result. |
| 00:06.036 | The agent is open and ready for the next request. |

The captured session took 11.545 seconds. The delivered recording is
6.839 seconds after shortening waits. The trial's process exit is shown
with the reminder to review its answer before using the agent for decisions.

## Dashboard

Typed in the parent Pi conversation:

```text
/pine dashboard
```

The browser dashboard shows the project's actual widgets. The recording
begins in its Notes view, with **Select multiple** already enabled.
Choose only **Delivery promise**, then **Send 1 selected to Pi**. The
one-item selection reference is added to Pi's unsent draft. The browser displays the acceptance
receipt; the person still decides when to submit the message.

The receipt reads **Added to Pi draft. Press Enter in Pi when ready.**
It is fully visible in the delivered video at 00:01.600, and the independent Pi draft contains
one selection reference with only that note. The captured browser session took 2.355 seconds;
the encoded video lasts 2.383 seconds after frame-rate quantization.

The recording contains actual browser frames at 920 × 538 pixels. The page
shows the complete browser frame. It does not paint a terminal receipt or
illustrative text over the recording.

## Facts

Typed in the saved agent's own conversation:

```text
/feedback fact: The maximum retry count is three.
/fix
```

Pine first saves one pending fact. The real maintenance workflow evaluates
the current and proposed agent, preserves the earlier revision and applies
the correction. The running agent reloads and reports **1 applied,
0 pending**.

Then ask:

```text
What is the maximum retry count?
```

The answer is **The maximum retry count is three.** The scripted endpoint
returns that answer only when the saved fact is present in the model's
loaded context. The question alone is insufficient.

| Recording time | What appears |
| --- | --- |
| 00:00.825 | The fact is saved as pending feedback. |
| 00:01.145 | `/fix` starts the correction checks. |
| 00:02.093 | The correction is applied and the agent reloads. |
| 00:03.245 | The next answer uses the newly loaded fact. |

The captured workflow took 31.257 seconds. The delivered recording is
4.070 seconds after shortening waits. Use representative tasks and your
chosen model to assess correction quality beyond this controlled example.

## Durable

Typed in the parent Pi conversation:

```text
/pine durable release-reader --model openai/gpt-5-mini
```

Pine exports a separate app to `./durable/release-reader` and explains what
needs an online adapter. A local herdr pane does not become a hosted pane.
The generated app includes team chat and a session inspector, while its
README names the hosting and integration work that remains.

In the exported directory, using Node 24:

```sh
npm install --ignore-scripts
npm run check
node --import tsx scripts/demo-smoke.ts > smoke-result.txt
node scripts/show-smoke.mjs
```

The demo copies the generated smoke script and changes only its scripted
model delay from 2.2 seconds to 0.18 seconds. The checks remain the same.
The final shell command reads the actual smoke result and prints its
summary. The local smoke run exercises real Harness turns, request signatures,
acknowledgement, replies, deduplication and worker recovery against
isolated loopback servers. Its model endpoint is scripted. No model
provider, GitHub or Slack account is contacted by the smoke run, and
this recording does not deploy an application.

The visible result is **PASS: 25 checks, 7 replies.** It reports the original
60ms Slack acknowledgement and 3662ms crash recovery measurements. Those are
measurements of this local smoke run. The captured session took 49.051 seconds;
the delivered recording is 4.722 seconds after shortening waits. The final
caption reminds you to choose hosting separately.

## Setup and data

Follow the [agent setup guide](https://pine-pi.vercel.app/install.md) for the pinned public package or
an exact local workspace copy. Success requires the loaded package version,
a passing doctor result and visibly rendered notes and tasks inside herdr.
All records in the recordings are disposable examples. No model credential
or private project is recorded. [Credits and provenance](https://pine-pi.vercel.app/credits.md) describe
the player, source recordings and poster captures.
