# Session 0003.0 — Transcript

> App: engineering
> Start: 2026-06-04T13-23 (PST)
> End: 2026-06-04T13-25 (PST)
> Type: coding
> Goal: Write a rule that an app's repos and environments may only be stood up via flotilla; at provisioning, a session hands the operator flotilla CLI instructions rather than provisioning itself. (Scoped by operator follow-up: initial provisioning only — ad hoc Gitea/cloud ops stay fine.)
> Outcome: **Shipped.** PR #11 merged to `main` (merge `c551b8b`). New canonical handbook §8.5 + named digest operating rule `flotilla-only-provisioning`.

## Plan

Add the **`flotilla-only-provisioning`** rule, docs-first (handbook canonical,
digest reflects):

- **Handbook** (`README.md`): new **§8.5 "Provisioning is a flotilla gesture"**
  (+ TOC entry) — initial stand-up of repos + environment goes through the
  `launch-app`/`flotilla-core` suite only; the agent hands the operator the
  flotilla command(s) and waits; operator-run gesture in both postures; ad hoc
  ops on existing resources unaffected.
- **Digest** (`agent-context.md`): new named operating rule
  `flotilla-only-provisioning` in the Operating-rules list + a pointer in the §8
  deploy section.
- Scope = **rule only** (operator decision); aligning the downstream plugin
  skills is a recorded follow-up. No formal spec/plan doc (operator decision).

## Pre-session state

`engineering` on clean, pushed `main` (right after session 0002's digest-rename
sweep merged, `ed7967c`). The session opened in the plugin repo's working dir but
the work targets the **engineering** repo. No other sessions in flight.

Existing provisioning landscape (recon): provisioning is the `launch-app`
orchestrator (phase skills `define-deployment`, `scaffold-gitea-repos`,
`provision-vm`) over the `flotilla-core` engine (verbs `deployment
scaffold|validate|import`, `flotilla init`, `flotilla deploy`), with
`scaffold-gcp-project` as the cloud-foundation phase. So "via flotilla" maps onto
the launch-app/flotilla suite; the rule formalizes it as the only front door for
*initial* stand-up.

## Turn-by-turn arc

1. **Gate already lifted** (session declared coding earlier this conversation);
   no re-gate. Classified the task as creative/policy work → invoked
   **brainstorming** (HARD-GATE: design before implementing).
2. **Recon.** Read handbook §8.2/§8.4, the `launch-app` SPEC (§1–§5), and
   `flotilla-core`'s real verbs to ground the rule in existing mechanics rather
   than invent a flotilla surface.
3. **Operator clarification (mid-work):** "Ad hoc operations against e.g. Gitea
   are ok. But initial provisioning must be via flotilla." → scoped the rule to
   **initial stand-up only**; ad hoc admin stays fine.
4. **Design + two forks** via `AskUserQuestion`: scope = **rule only** (not
   rule+skill-alignment); process = **skip formal spec/plan**. Design approved.
5. **Claim.** Prior transcript (0002) was already published, so claimed a fresh
   ID **0003** (`6ac0c0f`) before editing.
6. **Edit** on branch `docs/flotilla-only-provisioning-rule`: handbook TOC entry
   + §8.5 body; digest named rule + §8 pointer. Reviewed the full diff (42
   insertions, 2 files).
7. **Ship.** Commit (Co-Authored-By trailer) → push → **PR #11** via Gitea API →
   merge (`Do: merge`, HTTP 200) → sync local `main`, delete branch. Confirmed
   the rule present on `main` in both files.
8. **Finalize.** Recorded the skill-alignment follow-up in plugin memory; wrote +
   published this transcript.

## Cut state (end of session)

| Repo | Branch | Commits | State |
| --- | --- | --- | --- |
| engineering | main | `7eef7a4` (rule) → `c551b8b` (merge of PR #11) | merged, pushed; local main synced; feature branch deleted |

`README.md` +27 / `agent-context.md` +15; docs-only. Working tree clean on
`origin/main`.

## What lands on the operator's plate

The rule is canonical and live in the engineering repo. The one explicit
follow-up (recorded in the plugin project memory, **not** in this PR by design):
align the downstream plugin skills to the rule — `scaffold-gcp-project`,
`wgl-gitea-admin` (scope its repo-*creation* path to flotilla; keep
rename/visibility/etc. as ad hoc), and `wgl-session-coding-init`'s
`DEPLOY-FLOTILLA.md` card — in a later **plugin** session (edit plugin source +
version bump per CLAUDE.md).

## Prompt the operator can paste into the next session

The natural next step is the recorded follow-up — a plugin-repo session:

```
/goal Align the plugin skills to the new flotilla-only-provisioning rule (engineering §8.5): make scaffold-gcp-project / wgl-gitea-admin (repo-creation path only) / wgl-session-coding-init's DEPLOY-FLOTILLA card defer INITIAL provisioning to the launch-app/flotilla suite (hand the operator the flotilla command(s) rather than hand-provisioning); keep ad hoc Gitea/gcloud ops unchanged. Bump plugin.json. See plugin project memory.
```