Section 01

Oracle / Packing Context

Set up the oracle-packx skill, PackX bundle flow, Oracle browser runtime, MCP entrypoints, optional remote browser route, and local verification surfaces for this workspace.


setup agent prompt
Set up the oracle-packx skill, PackX bundle flow, Oracle browser runtime, MCP entrypoints, optional remote browser route, and local verification surfaces for this workspace.

1. Resolve the oracle-packx skill. Check `skills/oracle-packx/SKILL.md` first, then `~/.agents/skills/oracle-packx/SKILL.md`. Confirm the PackX references exist under `skills/oracle-packx/references/` or the matching installed skill path. Read the skill before changing config. If the skill is missing, report the missing path and the smallest install or copy step needed; do not invent skill content.

2. Verify PackX availability. Run `command -v packx || npx packx --help`. Confirm a preview command is available before building anything. Do not create a broad bundle during setup.

3. Verify Oracle entrypoints. Run `command -v oracle oracle-mcp` and report both results. If either command is missing, inspect `~/dev/oracle/docs/configuration.md`, `~/dev/oracle/docs/mcp.md`, `~/dev/oracle/docs/browser-mode.md`, and `~/dev/oracle/docs/bridge.md` if present, then report the exact missing install or PATH step.

4. Prepare local artifact directories. Confirm `~/.oracle/`, `~/.oracle/bundles/`, and `~/.oracle/sessions/` exist. Create only missing directories. Do not delete, overwrite, or rename existing sessions or bundles.

5. Configure Oracle for deliberate browser mode. Inspect `~/.oracle/config.json` if it exists, preserving existing private values. Ensure this workflow resolves to `engine: "browser"`, with browser thinking set to extended, model label set to Latest, browser attachments set to always, browser file bundling enabled, and `maxFileSizeBytes` set to a reasonable upload guardrail such as `10485760`. Do not clobber unrelated config.

6. Verify MCP/browser request fields. Confirm a setup run would pass or resolve these values: `engine: "browser"`, `browserThinkingTime: "extended"`, `browserModelLabel: "Latest"`, `browserAttachments: "always"`, and `browserBundleFiles: true`. Flag any condition where Oracle would fall back to API mode.

7. Optional remote browser route. If remote browser routing is intended, verify the config shape without exposing values: `browser.remoteHost` should look like a Tailscale host and port, `browser.remoteToken` should be present but redacted, and `browser.remoteChrome.host` plus `browser.remoteChrome.port` should point at the remote Chrome debug bridge from the remote server's perspective. If no remote route is configured, report it as skipped.

8. Enforce privacy boundaries. Never print or bundle tokens, cookies, API keys, private endpoints, raw `env` output, full private config, huge logs, generated output, `node_modules/`, `.git/`, build output, coverage output, or unrelated product areas. Confirm `CLAUDE.md` is excluded from Oracle PackX bundles. Use compact redacted notes when evidence is useful but unsafe or too large.

9. Verify the PackX context flow with a tiny dry run. From a safe local project path, run a preview against a narrow path or harmless file set using the skill's PackX reference. Report file count, token count if available, and whether the scope would produce a non-empty bundle. Do not upload files to Oracle during this preview.

10. Verify bundle and session surfaces. Using a short setup slug, confirm a bundle path like `~/.oracle/bundles/{slug}.txt` can be written and is non-empty if you build a tiny safe bundle. Confirm a session directory path like `~/.oracle/sessions/{slug}/` can exist, and that the expected post-run output file is `~/.oracle/sessions/{slug}/output.log`.

11. If a live browser Oracle smoke test is safe and explicitly allowed by the local environment, run only a minimal browser-mode check with harmless content. Otherwise stop before sending anything and report the remaining manual check: signed-in browser availability, remote host reachability if used, and expected `output.log` location.

12. Report the setup result plainly: skill path resolved, PackX status, Oracle CLI status, Oracle MCP status, directories present or created, browser-mode config status, resolved engine, remote route configured or skipped, preview result, bundle/session surface status, verification commands run, files created or changed, and anything still unproven. Redact all secrets and do not paste full config.

Workflow route

Oracle / Packing Context

Set up the oracle-packx skill, PackX bundle flow, Oracle browser runtime, MCP entrypoints, optional remote browser route, and local verification surfaces for this workspace.

Eggo seals the context bundle before launch for the Oracle / Packing Context workflow, making the page's operating move visible.
Intent

Name the software-workflow decision before launching work.

Evidence

Inspect the file, command, log, prompt, or recording that proves the state.

Route

Pick the narrow agent, tool, shell, or council path that matches the problem.

Verify

Confirm the result with output, screenshots, receipts, or saved decisions.

  1. Big Idea
  2. Try This Now
  3. Skill Reference
  4. When To Reach For This
  5. How This Used To Work
  6. Mental Model
unsafe loose scraps stay outside while the useful packet is ready

Big Idea

Phase: Context And Environment - make the software question, project boundary, and model runtime explicit before deeper work begins.

Use the oracle-packx skill when a software question needs more context than a normal chat turn can hold, or when the answer should come from a stronger browser-backed model with a deliberate context packet.

Try This Now

Pick one risky software question, such as “Why can this billing webhook double-process an invoice?”

Write one sentence for each boundary:

Ask:

snippet-1
Use the oracle-packx skill.

Build a bounded PackX bundle before recommending a fix. Use Oracle through
browser mode. Read the full Oracle output from the local session log before
turning it into project work.

Skill Reference

The repeatable workflow lives in the bundled skill:

snippet-2
skills/oracle-packx/SKILL.md

Supporting references:

snippet-3
skills/oracle-packx/references/packx-quick-reference.md
skills/oracle-packx/references/packx-deep-reference.md

A common local install path is:

snippet-4
~/.agents/skills/oracle-packx/SKILL.md

Oracle project reference:

snippet-5
https://github.com/johnlindquist/oracle

PackX package and reference:

snippet-6
https://www.npmjs.com/package/packx
https://github.com/johnlindquist/pack#readme

When To Reach For This

Use oracle-packx when you are asking for:

Skip it when:

How This Used To Work

What you used to expect:

snippet-7
Paste a broad prompt and trust the model to infer the right files.

What this workflow gives you now:

snippet-8
Give oracle-packx a specific software question. It builds a bounded context
packet first, then Oracle reasons over the code, docs, logs, and evidence that
actually matter.

Mental Model

There are three pieces:

PieceJob
oracle-packxWorkflow wrapper: choose scope, preview PackX, build the bundle, call Oracle, read the result, apply it locally
PackXContext bundler: collect, filter, count, and write source context into an LLM-friendly packet
OracleModel runner: CLI/MCP tool that can use API mode or browser mode, then save session output locally

Do not blur those together. PackX prepares the context. Oracle reasons over it. The agent still owns local edits and verification.

Oracle Runtime Setup

Oracle can run from the CLI or from the MCP tool.

Common entrypoints:

snippet-9
oracle
oracle-mcp

The project includes browser-mode code, MCP tools, remote-browser routing, session storage, and launch helpers.

Useful project files to inspect:

snippet-10
~/dev/oracle/docs/browser-mode.md
~/dev/oracle/docs/configuration.md
~/dev/oracle/docs/mcp.md
~/dev/oracle/docs/bridge.md
~/dev/oracle/src/mcp/server.ts
~/dev/oracle/src/mcp/tools/consult.ts
~/dev/oracle/src/mcp/tools/sessions.ts
~/dev/oracle/src/mcp/tools/sessionResources.ts
~/dev/oracle/src/config.ts
~/dev/oracle/src/remote/client.ts
~/dev/oracle/src/remote/server.ts
~/dev/oracle/src/browser/index.ts
~/dev/oracle/scripts/oracle-serve-launchagent.sh

Oracle session output is saved under:

snippet-11
~/.oracle/sessions/{slug}/

For oracle-packx, the main file to read after the run is normally:

snippet-12
~/.oracle/sessions/{slug}/output.log

Browser Mode

Browser mode sends the request through an automated signed-in browser session instead of the normal API path.

Use it when the answer should come from ChatGPT/Gemini web capabilities, attached files, a visible remote browser, or a browser-only model surface.

Critical MCP fields:

snippet-13
engine: "browser"
browserThinkingTime: "extended"
browserModelLabel: "Latest"

Why engine: "browser" matters:

Browser attachment controls:

snippet-14
browserAttachments: "always"
browserBundleFiles: true

Use browserAttachments: "always" when files must be uploaded through the browser UI. Use bundling when many files should travel as one uploaded context artifact.

Tailscale TV Oracle Path

A common remote setup uses a Tailscale-reachable Oracle browser host. This lets the local agent send the job while the remote machine drives an already signed-in browser session, often visible on a TV or second display.

The path looks like this:

snippet-15
local Codex / agent
  -> Oracle MCP consult or oracle CLI
  -> browser engine
  -> browser.remoteHost over Tailscale
  -> remote oracle serve process
  -> remoteChrome on the remote host
  -> signed-in ChatGPT/Gemini browser
  -> local ~/.oracle/sessions/{slug}/ output

Redacted config shape:

json
{
  "engine": "browser",
  "browser": {
    "remoteHost": "100.x.y.z:7333",
    "remoteToken": "<redacted>",
    "remoteChrome": {
      "host": "127.0.0.1",
      "port": 55894
    }
  },
  "maxFileSizeBytes": 10485760
}

What each field means:

FieldMeaning
engineDefault Oracle runtime mode
browser.remoteHostTailscale-reachable Oracle remote server
browser.remoteTokenBearer-style token required by the remote server
browser.remoteChrome.hostChrome debugging host from the remote server’s point of view
browser.remoteChrome.portChrome debugging port on the remote machine
maxFileSizeBytesLocal upload guardrail for files sent to browser mode

The token is private. Do not paste it into prompts, bundles, pages, logs, or screenshots.

Ask The Agent This

General review:

snippet-17
Use the oracle-packx skill.

Review the auth/session architecture before we add refresh-token rotation.
Build a focused PackX bundle from the auth package, session storage code,
middleware, relevant tests, and existing ADRs. Exclude secrets, generated
output, node_modules, and unrelated product areas.

Ask Oracle through browser mode for risks, a migration plan, file-level changes,
verification checks, rollback notes, and the first shippable slice. Read the
full Oracle session output before editing local files.

Debugging:

snippet-18
Use the oracle-packx skill.

The billing webhook intermittently double-processes an invoice. Bundle the
webhook handler, idempotency code, tests, payment-provider docs, and the latest
failure log. Ask Oracle through browser mode to identify likely causes, missing
invariants, and the smallest local check that would confirm the fix.

Remote browser setup check:

snippet-19
Use the oracle-packx skill.

Inspect the local Oracle config and explain whether browser mode will route to a
remote Tailscale Oracle host. Redact tokens and private host details. Confirm the
engine choice, remoteHost shape, remoteChrome target, file-size guardrail, and
where the session output will be saved.

Keep the bundle tight:

snippet-20
Use the oracle-packx skill.

Start with a PackX preview. If the bundle is too broad, narrow by package,
entrypoint, git diff, or relevant search terms before consulting Oracle. Do not
send secrets, generated files, private env output, or raw huge logs.

What The Skill Does

The oracle-packx skill runs this pipeline:

  1. Choose a short slug.
  2. Preview the PackX bundle before building it.
  3. Build a rich bundle, often targeting up to 900k tokens for broad review.
  4. Confirm the bundle exists and is non-empty.
  5. Add compact evidence when raw logs or sessions are too large or unsafe.
  6. Send the bundle to Oracle through browser mode only.
  7. Use ChatGPT Pro Extended or equivalent browser thinking controls.
  8. Wait for Oracle instead of doing parallel local work.
  9. Read the full answer from ~/.oracle/sessions/{slug}/output.log.
  10. Turn Oracle’s answer into local implementation work.
  11. Write local plans, notes, code, or verification logs with local tools.

What PackX Is Doing

PackX discovers files, applies ignore rules, filters by path/content/git state, optionally strips comments or minifies, counts tokens, and writes an LLM-friendly bundle.

Common PackX capabilities used by the skill:

CapabilityWhat It Means
--previewDry run before building the bundle
--limit 900kRich bundle target for broad Oracle review
-x / --excludeLeave out noise or unsafe files
-i / --includeInclude specific path/glob patterns
-s / --stringsFind files containing relevant text
--diff / --dirty / --stagedFocus on changed files
--follow-importsStart from an entrypoint and include local imports
--skeletonSend API/interface shape without full bodies
--strip-comments --minifyFit large projects into the bundle
-f markdown --no-interactive --stdoutScriptable output shape for Oracle

Use these flags conceptually. The exact combinations live in the skill and quick reference.

What To Exclude

The skill explicitly excludes CLAUDE.md from Oracle PackX bundles.

Why:

Prefer a scoped AGENTS.md, project README, ADR, or short local summary when instructions are needed.

Also keep these out unless there is a deliberate reason:

snippet-21
node_modules/
.git/
dist/
build/
.next/
coverage/
*.log
lockfiles
raw env output
tokens
cookies
private endpoints

Logs can still be included intentionally when they are small and directly relevant. Large logs should usually become compact evidence.

Compact Evidence

Use compact evidence when the raw material is useful but too noisy, too large, or unsafe to bundle directly.

Examples:

Shape:

markdown
# Compact Evidence Supplement

## Useful Facts

- fact:
- source path:
- why it matters:

## Raw Context Intentionally Omitted

- path:
- omitted because:

## Current Narrowing

- next slice:
- out of scope:
- how to confirm:

How To Know It Worked

After the skill runs, look for:

If It Goes Wrong

SymptomLikely CauseWhat To Do
Oracle used API modeengine: "browser" was omitted or config default changedRe-run with explicit browser engine
Browser did not openBrowser automation or remote host is unavailableCheck local Oracle config and browser-mode docs
Remote host unreachableTailscale, host, port, or remote server is downConfirm the 100.x.y.z:port route and remote oracle serve process
Token rejectedRemote token mismatchRotate or fix the token outside the bundle and prompt
Remote Chrome unavailableDebug port or Chrome session is not running on the remote hostRestart the remote Chrome/debug bridge or launch helper
File upload rejectedBundle or attachment exceeded guardrailsNarrow PackX scope, use compact evidence, or bundle fewer files
Bundle is hugeScope was too broadPreview again with tighter includes, excludes, strings, diff, or entrypoints
Bundle is emptyInclude patterns missed the actual filesRun rg, inspect paths, and rebuild
Oracle answer is vagueContext packet lacked logs, tests, or target questionAdd compact evidence and ask for a falsifiable first check
Sensitive data appearsSecrets or raw env output slipped inStop, remove the bundle, rebuild with redaction

Follow-Up Rules

Oracle’s answer is input, not the finished work.

After reading it:

When returning to Oracle, include the delta:

snippet-23
- prior_oracle_session:
- last_oracle_recommendation:
- implemented_since_prior_oracle:
- verified_since_prior_oracle:
- failed_check_or_blocker:
- narrowing_decision:
- files_functions_now_in_scope:
- files_functions_out_of_scope:
- next_falsifiable_verification:

References And Resources

snippet-24
skills/oracle-packx/SKILL.md
skills/oracle-packx/references/packx-quick-reference.md
skills/oracle-packx/references/packx-deep-reference.md
~/dev/oracle/docs/browser-mode.md
~/dev/oracle/docs/configuration.md
~/dev/oracle/docs/mcp.md
~/dev/oracle/docs/bridge.md
~/.oracle/config.json
~/.oracle/bundles/{slug}.txt
~/.oracle/sessions/{slug}/output.log