---
schema_version: 1
revision: "22ce5d34dbcb5a78"
id: "factory-reasoning-and-video-practice"
title: "Independent reasoning and video evidence — prompts and exercises"
---

# Independent reasoning and video evidence — prompts and exercises

Complete reusable prompts, setup recipes, success checks, and caveats for independent reasoning and video evidence.

## Quick start

Sign into chatgpt.com in your normal Chrome first — a human does that part, once. Then:

``` text
npm install -g @steipete/oracle    # or: brew install steipete/tap/oracle (Node 22+)
oracle --engine browser -p "HI"    # first handshake: copies your cookies, sends "HI"
oracle status --hours 72           # the reply is recorded as a replayable session
```

## Prompt library

### The maximum-batch consult

- Agent: oracle CLI → ChatGPT (GPT-5.6 Pro)
- Working directory: your project root
- Expected result: ordered work packages with file/function/test targets, 20–60 min later

This is the pattern behind ~1,978 real consult sessions. Fill the `<angle-bracket>` slots with your project's facts; the last two paragraphs ship verbatim with every consult. Save it as `consult-prompt.md`.

``` text
[<three-to-five-word-slug>]

## Project briefing
<stack, framework, runtime, and repo rules — two or three sentences>

## Goal
<the full outcome you want, stated as the whole contract Oracle must plan
against — never pre-shrunk to a first step>

## Prior-State Ledger
- prior_oracle_session: none
- implemented_since_prior_oracle: none
- verified_since_prior_oracle: none
- failed_proof_or_blocker: none
- remaining_goal_coverage: the full goal above

## Current evidence
<attempts, failing logs, screenshots, and known constraints — or "none yet">

## Bundle map
The attached files contain <what you included and why>. Possibly missing:
<what you could not include>.

## Deliverable
Return the maximum actionable batch: an ordered set of work packages covering
everything worth doing toward the goal. Every work package must carry exact
file/function/test targets, critical code snippets, and a falsifiable
verification. Sequence the packages, name risks and invariants, and put
anything you cannot target exactly in a separate short "needs investigation"
list.

Return your answer as text in this response only. Do not create, attach, export,
or offer any downloadable file. Do not create local project artifacts yourself.
The local agent will write any needed files, plans, notes, goals, commits, or
verification logs using local tools.

Plan the maximum actionable batch: cover everything worth doing toward the
goal in ordered work packages with exact file/function/test targets and a
falsifiable verification each. Do not return a single next step or hold work
back for a later round. An ambitious, specific answer is correct; only
untargeted vagueness is a defect.
```

Run it with your code attached:

``` text
oracle --engine browser -p "$(cat consult-prompt.md)" \
  --file "src/**/*.ts,docs/**/*.md" --slug "<three-to-five-word-slug>"
```

### The sentinel video probe

- Agent: oracle CLI → Gemini
- Working directory: anywhere, with a short MP4 on disk
- Expected result: three bullets plus the exact sentinel line, byte-for-byte

Before any expensive video run, prove the upload path with a cheap probe. Save this as `probe-prompt.md`:

``` text
[video-upload-smoke-probe]

This is an attached-video readiness probe for a longer video analysis run.

Confirm that you can inspect the attached video. Return exactly three short bullets:
- whether video frames are visible;
- whether audio is detectable;
- one strictly observed visual detail, without guessing.

End with this exact sentinel on its own line:
END_OF_VIDEO_ANALYSIS video-upload-smoke-probe probe
```

``` text
oracle --engine browser --model gemini-3-pro --browser-attachments always \
  -p "$(cat probe-prompt.md)" --file "/absolute/path/to/probe-clip.mp4" \
  --slug "video-upload-smoke-probe"
```

The pass rule: the sentinel comes back byte-exact and the observed detail matches your footage. A paraphrase, extra prose, or silence means the path is broken — fix it before the long run, not after.

### The shard analysis prompt — Loop Craft, verbatim

- Agent: oracle CLI → Gemini
- Working directory: a video run folder with a ≤4-minute shard
- Expected result: dense Markdown + machine JSON, ending in the exact sentinel

This exact prompt produced shard 001 of the [Loop Craft wiki](https://silken-ferry-63mw.here.now/). Swap the metadata block and the sentinel for your own run; keep the evidence rules — they are what stop Gemini from inventing URLs, commands, and speakers.

``` text
[loopcraft-workshop-shard-001-source-native]

Analyze the attached source-native video shard for an extensive public workshop wiki.

Metadata:
- run_key: loopcraft-agent-workshop
- shard_id: 001
- original recording range: 00:00:00–00:04:00
- publication chapter: Workshop Setup and the Looping Resolver

Evidence rules:
1. Use original workshop timestamps from 00:00:00 through 00:04:00.
2. Separate spoken evidence, visible screen evidence, and inference.
3. Listen to the audio; do not rely on automatic captions.
4. Do not invent commands, URLs, files, tools, speakers, or UI labels.
5. Pull quotes must be brief (under 20 words), audio-verified, attributed to Joel Hooks, and timestamped.
6. Exclude credentials, account details, local paths/usernames, private URLs, signed URLs, notifications, or incidental personal data.
7. Treat opinions and live-demo observations as such, not universal facts.
8. Derived prompts must use placeholders, be clearly labeled as inspired by the workshop, and require confirmation for destructive or externally visible actions.

Return dense Markdown with these sections:
# Shard 001 — 00:00:00–00:04:00
## Executive Takeaway
## Dense Timeline
## Concepts and Mental Models
## Visible Demo Evidence
## Architecture and Workflow Patterns
## Tools, Commands, and References
## Pull Quote Candidates
## Copy/Paste AI Prompt Candidates
## Student Exercises and Reflection Questions
## Keyframes to Capture
## Uncertainties and Publication Review
## Machine JSON

The fenced JSON object must contain: shard_id, original_range, summary, timeline, concepts, workflows, demos, resources, quotes, prompts, exercises, keyframes, warnings, unanswered_questions.

End with this exact sentinel on its own line:
END_OF_VIDEO_ANALYSIS loopcraft-agent-workshop shard-001
```

## Set it up (agent guide)

1.  Check prerequisites: Node 22+ and Google Chrome installed.

    ``` text
    node --version   # need v22 or newer; Chrome must also be installed
    ```

2.  Install the Oracle CLI.

    ``` text
    npm install -g @steipete/oracle
    oracle --version
    ```

3.  Sign into chatgpt.com in your normal Chrome. **A human does this step** — an agent cannot log in for you. Oracle borrows the session cookies from that logged-in profile.

4.  Run the first handshake. Oracle copies your cookies into a temporary automation profile, opens ChatGPT, and sends the prompt.

    ``` text
    oracle --engine browser -p "HI"
    ```

5.  Create your first real consult. Save this file and replace every `<angle-bracket>` slot with facts from your project:

    ``` text
    [<three-to-five-word-slug>]

    ## Project briefing
    <stack, framework, runtime, and repo rules — two or three sentences>

    ## Goal
    <the full outcome you want, stated as the whole contract Oracle must plan
    against — never pre-shrunk to a first step>

    ## Prior-State Ledger
    - prior_oracle_session: none
    - implemented_since_prior_oracle: none
    - verified_since_prior_oracle: none
    - failed_proof_or_blocker: none
    - remaining_goal_coverage: the full goal above

    ## Current evidence
    <attempts, failing logs, screenshots, and known constraints — or "none yet">

    ## Bundle map
    The attached files contain <what you included and why>. Possibly missing:
    <what you could not include>.

    ## Deliverable
    Return the maximum actionable batch: an ordered set of work packages covering
    everything worth doing toward the goal. Every work package must carry exact
    file/function/test targets, critical code snippets, and a falsifiable
    verification. Sequence the packages, name risks and invariants, and put
    anything you cannot target exactly in a separate short "needs investigation"
    list.

    Return your answer as text in this response only. Do not create, attach, export,
    or offer any downloadable file. Do not create local project artifacts yourself.
    The local agent will write any needed files, plans, notes, goals, commits, or
    verification logs using local tools.

    Plan the maximum actionable batch: cover everything worth doing toward the
    goal in ordered work packages with exact file/function/test targets and a
    falsifiable verification each. Do not return a single next step or hold work
    back for a later round. An ambitious, specific answer is correct; only
    untargeted vagueness is a defect.
    ```

6.  Run the consult with your code attached. A GPT-5.6 Pro consult takes 20–60 minutes of wall clock — wait for it; the session log is the durable record.

    ``` text
    oracle --engine browser -p "$(cat consult-prompt.md)" \
      --file "src/**/*.ts" --slug "<three-to-five-word-slug>"
    ```

**Success check:** a response was received and recorded. The handshake and your consult both appear as sessions:

``` text
oracle status --hours 24
```

The session browser should report the completed model run; inspect the returned artifact rather than trusting a short status alone.

## Attachments — the Oracle skill family

These are the presenter's real skill files, verbatim — the same six skills that drive everything on this page: `oracle` (the maximum-batch consult contract, plus its packx references and round-robin scripts), `oracle-execute` (Oracle-planned execution loops), `oracle-schedule` (one scheduled future consult), `oracle-video` (the Gemini video pipeline, with its repeatable follow-up process), `oracle-video-create` (Gemini video generation), and `imagine` (ChatGPT image generation).

They orchestrate Oracle's browser engine plus packx and assume the presenter's accounts and setup — the round-robin pieces are pinned to one private pool you don't have. Install them to **study and adapt to your own accounts**, not to run unmodified. One block downloads all six into a staging folder and installs them into the current project. Two verified gotchas baked in: `.md` files must be fetched with `?raw` (the bare URL returns an HTML viewer page), and the staging folder must *not* be named `skills/` — the installer claims `./skills/` as one of its own targets and would clobber your downloads with empty symlinks.

``` text
BASE=https://shiny-rosette-m6zy.here.now/skills
D=oracle-skill-family
mkdir -p $D/oracle/references $D/oracle/scripts $D/oracle-execute \
  $D/oracle-schedule/agents $D/oracle-video/references \
  $D/oracle-video-create $D/imagine/agents
curl -fsS "$BASE/oracle/SKILL.md?raw" -o $D/oracle/SKILL.md
curl -fsS "$BASE/oracle/references/round-robin-receipt.md?raw" -o $D/oracle/references/round-robin-receipt.md
curl -fsS "$BASE/oracle/references/round-robin-transport.md?raw" -o $D/oracle/references/round-robin-transport.md
curl -fsS "$BASE/oracle/references/packx-quick-reference.md?raw" -o $D/oracle/references/packx-quick-reference.md
curl -fsS "$BASE/oracle/references/packx-deep-reference.md?raw" -o $D/oracle/references/packx-deep-reference.md
curl -fsS "$BASE/oracle/scripts/extract_codex_conversation.py" -o $D/oracle/scripts/extract_codex_conversation.py
curl -fsS "$BASE/oracle/scripts/run_round_robin.sh" -o $D/oracle/scripts/run_round_robin.sh
curl -fsS "$BASE/oracle-execute/SKILL.md?raw" -o $D/oracle-execute/SKILL.md
curl -fsS "$BASE/oracle-schedule/SKILL.md?raw" -o $D/oracle-schedule/SKILL.md
curl -fsS "$BASE/oracle-schedule/agents/openai.yaml" -o $D/oracle-schedule/agents/openai.yaml
curl -fsS "$BASE/oracle-video/SKILL.md?raw" -o $D/oracle-video/SKILL.md
curl -fsS "$BASE/oracle-video/references/repeatable-video-followup-process.md?raw" -o $D/oracle-video/references/repeatable-video-followup-process.md
curl -fsS "$BASE/oracle-video-create/SKILL.md?raw" -o $D/oracle-video-create/SKILL.md
curl -fsS "$BASE/imagine/SKILL.md?raw" -o $D/imagine/SKILL.md
curl -fsS "$BASE/imagine/agents/openai.yaml" -o $D/imagine/agents/openai.yaml
chmod +x $D/oracle/scripts/extract_codex_conversation.py $D/oracle/scripts/run_round_robin.sh
npx skills add ./$D --skill '*' -y
```

To install just one skill instead of all six, change the last line — for example `npx skills add ./oracle-skill-family --skill oracle -y`.

## Complete reusable setup contract

## Oracle: Maximum Intelligence and Video — agent setup guide

Following this file sets up: a local Oracle CLI that drives ChatGPT through your user's logged-in Chrome browser (no API keys) and runs a first maximum-batch consult against the current project.

Human-facing companions at this site (context for your user, not steps for you): https://shiny-rosette-m6zy.here.now/replay.html is an annotated session replay of the real video-analysis run this workflow comes from, and https://shiny-rosette-m6zy.here.now/dialogue.html answers the common skeptical questions. This file remains the canonical executable path. The presenter's six real Oracle skill files are also attached at this site — see "Attachments" at the bottom of this file for the download URLs and install block.

Placeholders used below: `<project-root>` = the project you are working in; `<three-to-five-word-slug>` = a slug you choose, 3–5 hyphenated words (Oracle rejects anything outside that range). All other paths are literal.

## Prerequisites

Check each before starting:

```bash
node --version
```

Expected: `v22` or newer. Google Chrome must also be installed, and your user needs a ChatGPT account. If a tool is missing, stop and tell your user what to install.

## Steps

1. Install the Oracle CLI globally and confirm it runs:

   ```bash
   npm install -g @steipete/oracle
   oracle --version
   ```

2. Ask your user to sign into chatgpt.com in their normal Chrome profile. **A human must do this step — you cannot log in for them.** Oracle copies the session cookies from that logged-in profile into a temporary automation profile; the login is the entire auth setup. Wait for your user to confirm they are signed in before continuing.

3. Run the first browser handshake. This copies the cookies, opens ChatGPT in an automated Chrome, and sends the prompt:

   ```bash
   oracle --engine browser -p "HI"
   ```

   A reply coming back (any reply) proves the cookie path works.

4. Create `<project-root>/consult-prompt.md` with exactly this content, then replace every `<angle-bracket>` slot with real facts from the current project (read the code first — the briefing, goal, and bundle map must be true, not generic). Keep the final two paragraphs verbatim; they are the contract that makes the consult worth its cost:

   ```markdown
   [<three-to-five-word-slug>]

   ## Project briefing
   <stack, framework, runtime, and repo rules — two or three sentences>

   ## Goal
   <the full outcome you want, stated as the whole contract Oracle must plan
   against — never pre-shrunk to a first step>

   ## Prior-State Ledger
   - prior_oracle_session: none
   - implemented_since_prior_oracle: none
   - verified_since_prior_oracle: none
   - failed_proof_or_blocker: none
   - remaining_goal_coverage: the full goal above

   ## Current evidence
   <attempts, failing logs, screenshots, and known constraints — or "none yet">

   ## Bundle map
   The attached files contain <what you included and why>. Possibly missing:
   <what you could not include>.

   ## Deliverable
   Return the maximum actionable batch: an ordered set of work packages covering
   everything worth doing toward the goal. Every work package must carry exact
   file/function/test targets, critical code snippets, and a falsifiable
   verification. Sequence the packages, name risks and invariants, and put
   anything you cannot target exactly in a separate short "needs investigation"
   list.

   Return your answer as text in this response only. Do not create, attach, export,
   or offer any downloadable file. Do not create local project artifacts yourself.
   The local agent will write any needed files, plans, notes, goals, commits, or
   verification logs using local tools.

   Plan the maximum actionable batch: cover everything worth doing toward the
   goal in ordered work packages with exact file/function/test targets and a
   falsifiable verification each. Do not return a single next step or hold work
   back for a later round. An ambitious, specific answer is correct; only
   untargeted vagueness is a defect.
   ```

5. Run the consult from `<project-root>`, attaching the relevant source files (adjust the glob to the project's language):

   ```bash
   oracle --engine browser -p "$(cat consult-prompt.md)" \
     --file "src/**/*.ts" --slug "<three-to-five-word-slug>"
   ```

   A GPT-5.6 Pro consult takes 20–60 minutes of wall clock. Wait for it. Do not assume it timed out based on elapsed time alone — check the session (step 6) instead of restarting.

## Success check

Success = a response was received. Run:

```bash
oracle status --hours 24
```

Expected observable result: a "Recent Sessions" table listing your handshake and your consult slug with Status `completed`, Model `gpt-5.6-pro` (the handshake may show a different model), Mode `browser`, and a non-zero Chars count. Read the full response with:

```bash
oracle session "<three-to-five-word-slug>" --render
```

Report to your user: that Oracle is installed and cookie-authenticated, the consult slug, the success-check output, and a summary of the work packages Oracle returned — every package, not a trimmed selection.

## Notes for agents

- `Missing OPENAI_API_KEY` means the call fell into API mode. That is a caller bug, not a missing credential — retry with `--engine browser`.
- `Inspected target navigated or closed` mid-run: retry with `--browser-auto-reattach-delay 5s --browser-auto-reattach-interval 3s --browser-auto-reattach-timeout 60s`.
- If the handshake fails, the most likely cause is that the user is not actually signed into chatgpt.com in their normal Chrome. Ask them to check before debugging anything else.
- Browser automation is experimental and most stable on macOS. On Linux, pass `--browser-chrome-path` / `--browser-cookie-path` if Chrome detection fails.
- The CLI's terminal output can truncate long answers. The authoritative record is the session log at `~/.oracle/sessions/<slug>/output.log`, also readable via `oracle session <slug> --render`.
- Remote option (note only — do not set this up unless your user asks): an always-on machine can run `oracle serve` with its own signed-in Chrome, and clients point at it by setting the remote host and token in `~/.oracle/config.json`. The cookies then live once, on that host, for every client. Local mode is the right default.
- Video analysis uses the same CLI with `--model gemini-3-pro --browser-attachments always` and a Gemini login in Chrome, and every expensive run should be preceded by a cheap sentinel probe. The prompt library at https://shiny-rosette-m6zy.here.now/ has the liftable probe prompt/command pair.

## Attachments — the Oracle skill family (optional)

The presenter's six real skill files are published verbatim under `https://shiny-rosette-m6zy.here.now/skills/`. They orchestrate Oracle's browser engine plus packx and assume the presenter's accounts and setup (the round-robin pieces are pinned to a private pool you don't have) — install them to study and adapt, not to run unmodified. Only do this if your user asks for the skills.

here.now gotcha: `.md` files must be fetched with `?raw` (the bare `.md` URL returns an HTML viewer page). The raw file URLs:

- https://shiny-rosette-m6zy.here.now/skills/oracle/SKILL.md?raw
- https://shiny-rosette-m6zy.here.now/skills/oracle/references/round-robin-receipt.md?raw
- https://shiny-rosette-m6zy.here.now/skills/oracle/references/round-robin-transport.md?raw
- https://shiny-rosette-m6zy.here.now/skills/oracle/references/packx-quick-reference.md?raw
- https://shiny-rosette-m6zy.here.now/skills/oracle/references/packx-deep-reference.md?raw
- https://shiny-rosette-m6zy.here.now/skills/oracle/scripts/extract_codex_conversation.py
- https://shiny-rosette-m6zy.here.now/skills/oracle/scripts/run_round_robin.sh
- https://shiny-rosette-m6zy.here.now/skills/oracle-execute/SKILL.md?raw
- https://shiny-rosette-m6zy.here.now/skills/oracle-schedule/SKILL.md?raw
- https://shiny-rosette-m6zy.here.now/skills/oracle-schedule/agents/openai.yaml
- https://shiny-rosette-m6zy.here.now/skills/oracle-video/SKILL.md?raw
- https://shiny-rosette-m6zy.here.now/skills/oracle-video/references/repeatable-video-followup-process.md?raw
- https://shiny-rosette-m6zy.here.now/skills/oracle-video-create/SKILL.md?raw
- https://shiny-rosette-m6zy.here.now/skills/imagine/SKILL.md?raw
- https://shiny-rosette-m6zy.here.now/skills/imagine/agents/openai.yaml

Second verified gotcha: stage the downloads in a folder that is NOT named `skills/`. The `npx skills add` installer claims `./skills/` as one of its own install targets (OpenClaw) and will replace your staged source with empty symlinks, installing nothing. Download all six into `./oracle-skill-family/` and install them into the current project:

```bash
BASE=https://shiny-rosette-m6zy.here.now/skills
D=oracle-skill-family
mkdir -p $D/oracle/references $D/oracle/scripts $D/oracle-execute \
  $D/oracle-schedule/agents $D/oracle-video/references \
  $D/oracle-video-create $D/imagine/agents
curl -fsS "$BASE/oracle/SKILL.md?raw" -o $D/oracle/SKILL.md
curl -fsS "$BASE/oracle/references/round-robin-receipt.md?raw" -o $D/oracle/references/round-robin-receipt.md
curl -fsS "$BASE/oracle/references/round-robin-transport.md?raw" -o $D/oracle/references/round-robin-transport.md
curl -fsS "$BASE/oracle/references/packx-quick-reference.md?raw" -o $D/oracle/references/packx-quick-reference.md
curl -fsS "$BASE/oracle/references/packx-deep-reference.md?raw" -o $D/oracle/references/packx-deep-reference.md
curl -fsS "$BASE/oracle/scripts/extract_codex_conversation.py" -o $D/oracle/scripts/extract_codex_conversation.py
curl -fsS "$BASE/oracle/scripts/run_round_robin.sh" -o $D/oracle/scripts/run_round_robin.sh
curl -fsS "$BASE/oracle-execute/SKILL.md?raw" -o $D/oracle-execute/SKILL.md
curl -fsS "$BASE/oracle-schedule/SKILL.md?raw" -o $D/oracle-schedule/SKILL.md
curl -fsS "$BASE/oracle-schedule/agents/openai.yaml" -o $D/oracle-schedule/agents/openai.yaml
curl -fsS "$BASE/oracle-video/SKILL.md?raw" -o $D/oracle-video/SKILL.md
curl -fsS "$BASE/oracle-video/references/repeatable-video-followup-process.md?raw" -o $D/oracle-video/references/repeatable-video-followup-process.md
curl -fsS "$BASE/oracle-video-create/SKILL.md?raw" -o $D/oracle-video-create/SKILL.md
curl -fsS "$BASE/imagine/SKILL.md?raw" -o $D/imagine/SKILL.md
curl -fsS "$BASE/imagine/agents/openai.yaml" -o $D/imagine/agents/openai.yaml
chmod +x $D/oracle/scripts/extract_codex_conversation.py $D/oracle/scripts/run_round_robin.sh
npx skills add ./$D --skill '*' -y
```

To install a single skill instead of all six, change the last line, e.g. `npx skills add ./oracle-skill-family --skill oracle -y`. After installing, verify: `.agents/skills/<name>/` in the project must contain every downloaded file (multi-file skills keep their `references/` and `scripts/` subfolders).

## Original references

- [Independent reasoning and video evidence](https://shiny-rosette-m6zy.here.now/)
- [Public setup contract](https://shiny-rosette-m6zy.here.now/agent.md)
