the_local 0.2.0 → 0.4.0

data/PROVIDERS.md

@@ -6,134 +6,73 @@ of a project's direct dependencies into `.claude/agents/` — by reading each
 dependency's committed `.md` straight from its gem path on disk. This document
 covers the **provider** side: how a gem contributes those locals.
 
-A provider registers its agents with `TheLocal.register` behind a soft
-`require "the_local"` guard, so the gem keeps working when `the_local` is absent.
-
-## Build at home, copy verbatim
-
-The agent *definition* (`the_local.rb` + `guide.md`) is the single source of
-truth. The provider **renders it to committed `.md` files** with a gem-side
-`the_local:build` task and commits those files to its own repo; the host install
-then **reads them straight from your gem's path on disk and copies them verbatim**
-into `.claude/agents/`. No provider code is loaded in the host and no register
-block runs there — the committed, shipped `.md` is the entire contract. If those
-files aren't committed and in the gemspec's `files`, the gem contributes nothing;
-if they are, it contributes everything, with no install-time wiring.
-
-So the rendered output depends only on the provider gem version — every app that
-installs the same version gets a byte-identical local, instead of the host
-re-rendering (and possibly drifting) from an in-memory definition. The committed
-`.md` is a reviewable build artifact: it lands in the gem's own PR. Keep it in
-sync with the definition by re-running `the_local:build` and committing the
-result whenever you change the guide or an agent's `body:`/`description:`.
-
-## The common command interface
-
-`the_local` exists to give every gem the **same command interface to apps**, so
-a host agent always finds the same shape no matter which gem it's delegating to.
-A provider exposes three lifecycle facets:
-
-| Facet | Purpose | Typical tools |
-|---|---|---|
-| **`info`** | Read-only. Explains what the gem offers — its API and conventions. Makes no changes. | `Read` |
-| **`install`** | Adds the gem to a host and sets it up **correctly** — the exact, gem-specific steps. | `Bash, Read, Edit` |
-| **worker** | The proactive domain worker the host routes real work to. Named `develop` for libraries you build against, `operate` for CLIs you run. | per domain |
+A provider commits a manifest, `the_local/interface.yml`, and the three locals
+authored from it at `the_local/agents/<gem>-{info,install,develop}.md`. It ships
+no Ruby of its own.
 
-`info` and `install` are universal; the worker's name varies by the gem's
-nature. Every agent embeds the provider's knowledge (`Reference.content`)
-verbatim — that knowledge is the single source of truth, so the locals never
-drift from the docs.
+## Declare the interface, author the locals
 
-## Adopting it — Rails-engine gems (generator)
+**The manifest is the one judgment call, and a human makes it.** It names the
+gem's public entry points and assigns each to the local that owns it:
 
-If the gem has Rails available in development (e.g. a mountable engine), scaffold
-the wiring with the generator:
+```yaml
+scope: <one line: the user-visible work this gem owns>
 
-```bash
-bin/rails g the_local:provider <gem_name> \
-  --scope "one-line phrase describing the gem's domain" \
-  [--prefix <filename-namespace>] \
-  [--worker develop|operate]
-```
+install:
+  - bin/rails g demo:install
 
-It creates, and wires up:
+develop:
+  - Demo.emit
 
+sources:
+  - lib/generators/demo/install_generator.rb
+  - lib/demo/emitter.rb
 ```
-lib/<gem>/reference.rb           # the Reference loader (single source of truth)
-lib/<gem>/reference/guide.md     # the knowledge, with TODO markers to fill in
-lib/<gem>/the_local.rb           # Companion.register! — info / install / <worker>
-lib/<gem>/the_local/agents/*.md  # the rendered locals, built + committed
-Gemfile                          # + gem "the_local", github: …  (soft, dev/test)
-lib/<gem>.rb                     # + require_relative "<gem>/the_local"
-Rakefile                         # + require "the_local/rake"  (rake the_local:build)
-```
 
-The generator builds the `.md` once on scaffold so they land in the diff for
-review. They are rendered from the TODO placeholder definition, so you rebuild
-them after filling in the real content (below).
-
-Then **fill in the scaffold** — this is the real work the generator can't do:
-
-1. Write `reference/guide.md` as the complete user-facing API. The bar is that
-   a host agent can do your gem's work *from the guide alone, without opening
-   your source*: surface the literal interface (exact signatures — arguments,
-   required vs optional, return) and a complete copy-paste recipe for the common
-   task, not prose about them. Its **Install** section must be the exact, correct
-   steps for *this* gem (for an engine: add the gem → `bundle install` → install
-   + run migrations → wire concerns / initializers), not a generic placeholder.
-   Replace every `TODO:` — `rake the_local:build` refuses a guide that keeps one.
-2. Tailor the three agent `body:` strings in `the_local.rb` to the gem.
-3. **Rebuild and commit the locals.** The scaffold built `.md` from the TODO
-   placeholders, so regenerate them from your real definition and commit them:
-
-   ```bash
-   rake the_local:build
-   git add lib/<gem>/the_local/agents
-   ```
-
-   Rebuild whenever the guide or an agent's `body:`/`description:` changes — the
-   host copies these bytes verbatim, so a stale commit ships stale locals.
-4. Add a `companion_test` asserting the facets register and each embeds
-   `Reference.content`, plus a **drift test** asserting each committed file
-   equals its `agent.to_markdown` (so a forgotten rebuild fails CI). See
-   `test/the_local/companion_test.rb` — the_local is its own provider and uses
-   exactly this wiring.
-
-## Adopting it — non-Rails gems (manual)
-
-A plain gem has no `bin/rails`, so do the same things by hand. `the_local` is
-itself a non-Rails provider built this way — mirror its own wiring
-(`lib/the_local/the_local.rb`, `lib/the_local/reference.rb`, the committed
-`lib/the_local/the_local/agents/`, and the `Rakefile`):
-
-1. `lib/<gem>/reference.rb` — a `Reference` module with `DIR`, `content`, and
-   `read(name)` reading from `lib/<gem>/reference/`.
-2. `lib/<gem>/reference/guide.md` — the knowledge (single source of truth).
-3. `lib/<gem>/the_local.rb` — a `Companion.register!` that calls `TheLocal.register`
-   with an `agents_dir` (where the committed `.md` live) and declares the
-   `info` / `install` / worker agents, followed by the guard:
-
-   ```ruby
-   TheLocal.register("<gem>", scope: "…",
-                     agents_dir: File.expand_path("the_local/agents", __dir__)) do |c|
-     # c.agent "info", …
-   end
-   ```
-
-   ```ruby
-   begin
-     require "the_local"
-     <Gem>::Companion.register!
-   rescue LoadError
-     # the_local not installed — <gem> works standalone.
-   end
-   ```
-4. `require_relative "<gem>/the_local"` from the gem's entrypoint (so your own
-   `the_local:build` and standalone use load the register block — a host never
-   needs it), and add `gem "the_local"` to the Gemfile (dev/test — an optional
-   companion, not a hard dependency).
-5. Add `require "the_local/rake"` to the `Rakefile`, then build, commit, and
-   **ship** the rendered locals — `rake the_local:build && git add
-   lib/<gem>/the_local/agents`, and make sure they're in the gemspec's `files`.
-   These committed bytes are the whole contract — what the host reads from disk;
-   rebuild and recommit on every change.
+`rake the_local:author` then runs the_local's creators against that declaration
+and the files under `sources:`, writing the three locals. The creators no longer
+guess at what matters — they document what you declared, verified against the
+code as it is now rather than against a README that may be stale.
+
+`rake the_local:check` enforces the contract in both directions: every declared
+entry point is documented by its own local, nothing undeclared appears anywhere,
+and nothing appears in a local it wasn't declared for.
+
+## What each local is for
+
+The three never overlap. One entry point, one local.
+
+| Local | Purpose | Tools |
+|---|---|---|
+| **`install`** | Hooking the gem into a consumer — the exact setup steps. | `Bash, Read, Edit` |
+| **`develop`** | Using the gem — calling its entry points from consuming code. | `Read, Write, Edit, Grep` |
+| **`info`** | Read-only catchall: what the gem is, and which of the other two to reach for. | `Read` |
+
+They are step-by-step implementation guides, kept as short as the job allows.
+Where a step takes a real decision, the local surfaces the question to the
+developer rather than choosing. A local never sends its reader into the
+provider's source.
+
+## The committed files are the contract
+
+The host install **reads them straight from your gem's path on disk and copies
+them verbatim** into `.claude/agents/` — no provider code is loaded in the host.
+If they aren't committed (and, for a packaged gem, in the gemspec's `files`), the
+gem contributes nothing.
+
+## Adopting it
+
+1. **Wire the tooling.** In a Rails-engine gem, run `bin/rails g the_local:provider`;
+   it adds `gem "the_local"` to the Gemfile and `require "the_local/rake"` to the
+   Rakefile. A plain gem does those two edits by hand.
+2. **Declare the interface.** Write `the_local/interface.yml`. Authoring refuses
+   to run without it.
+3. **Author.** Run `rake the_local:author`.
+4. **Check and commit.** Fix what `rake the_local:check` reports, then
+   `git add the_local`. For a packaged gem, make sure `the_local/**/*` is in the
+   gemspec's `files`.
+5. **Keep it current.** When the gem's public interface changes, update the
+   manifest and re-author. An internal-only change needs nothing.
+
+`the_local` is its own first provider and uses exactly this wiring;
+`test/the_local/dogfood_test.rb` asserts its committed locals match its manifest.

data/README.md

@@ -24,10 +24,14 @@ change, point at the repo instead:
 gem "the_local", github: "DYB-Development/the_local"
 ```
 
-The gem's core is Rails-free, but the primary documented workflow uses the
-`bin/rails g the_local:install` / `the_local:provider` generators, so those steps
-assume a Rails host. The `the_local:refresh` rake task and the register API work
-without Rails.
+The gem's core is Rails-free. `bundle exec the_local install` and the
+`the_local:check`/`the_local:refresh` rake tasks work without Rails; a Rails host
+can equivalently use the `bin/rails g the_local:install` / `the_local:provider`
+generators.
+
+Once installed, the locals themselves know the rest — the `the_local-info`,
+`the_local-install`, and `the_local-develop` agents explain, set up, and drive
+the_local, so this README stays short on purpose.
 
 ## Usage
 
@@ -37,21 +41,23 @@ There are two sides.
 app's own) into `.claude/agents/`, and write the delegation trigger:
 
 ```bash
-bin/rails g the_local:install
+bundle exec the_local install
 ```
 
-Install **copies each provider's committed `.md` verbatim** — the rendering
-happens in the provider gem at build time, not in the host — so every app on the
-same gem version gets a byte-identical local. Re-run `the_local:refresh` (rake)
-after a `bundle install`/`update` to re-sync.
+Install **copies each provider's committed `.md` verbatim** — no provider code is
+loaded — so every app on the same gem version gets a byte-identical local. Re-run
+it (or `rake the_local:refresh`) after a `bundle install`/`update` to re-sync.
 
-**Provider gem** — contribute the locals an app installs. A gem registers its
-agents with `TheLocal.register` behind a soft guard, exposing the common command
-interface (`info` / `install` / worker), then renders them to committed `.md`
-with `rake the_local:build`. Scaffold it with:
+**Provider gem** — contribute the locals an app installs. A gem declares its
+public interface in `the_local/interface.yml` and commits the three locals
+authored from it, `the_local/agents/<gem>-{info,install,develop}.md`; it ships no
+Ruby. `rake the_local:author` writes those locals against the declaration and the
+gem's current code, and `rake the_local:check` fails if they document more or less
+than was declared — so the docs never drift from the source. Wire the tooling
+with:
 
 ```bash
-bin/rails g the_local:provider <gem_name> --scope "the gem's domain"
+bin/rails g the_local:provider
 ```
 
 See [PROVIDERS.md](PROVIDERS.md) for the full provider guide, including the

data/lib/generators/the_local/provider_generator.rb

@@ -1,47 +1,24 @@
 # frozen_string_literal: true
 
 require "rails/generators"
-require "the_local/builder"
 
 module TheLocal
   module Generators
-    # `bin/rails g the_local:provider <gem_name>` — scaffolds the provider side
-    # of the_local into a gem: a Reference loader, a knowledge guide, and a
-    # Companion that registers the common command interface (info / install /
-    # worker) via TheLocal.register behind a soft `require "the_local"` guard.
-    #
-    # The companion app side is `the_local:install`; this is its mirror for the
-    # gems that *contribute* locals. See PROVIDERS.md.
     class ProviderGenerator < Rails::Generators::Base
       source_root File.expand_path("templates", __dir__)
 
       GEMFILE_LINE = %(gem "the_local")
       RAKEFILE_REQUIRE = %(require "the_local/rake")
 
-      desc "Scaffold the_local provider wiring (info/install/worker locals) into this gem"
-
-      argument :gem_name, type: :string, desc: "The providing gem's name, e.g. citizen"
-      class_option :prefix, type: :string,
-                            desc: "Agent filename namespace (defaults to the gem name)"
-      class_option :scope, type: :string, default: "TODO: one-line phrase describing this gem's domain",
-                           desc: "One-line domain phrase used in the delegation trigger"
-      class_option :worker, type: :string, default: "develop",
-                            desc: "Name of the domain worker facet (develop for libraries, operate for CLIs)"
+      desc "Wire the_local provider tooling into this gem"
 
       def relocate_to_gem_root
         self.destination_root = gem_root
       end
 
-      def create_reference
-        template "reference.rb.tt", "lib/#{lib_path}/reference.rb"
-      end
-
-      def create_guide
-        template "guide.md.tt", "lib/#{lib_path}/reference/guide.md"
-      end
-
-      def create_companion
-        template "the_local.rb.tt", "lib/#{lib_path}/the_local.rb"
+      def announce_next_step
+        say "Declare this gem's public interface in the_local/interface.yml, then " \
+            "run `rake the_local:author` to write its locals into the_local/agents/."
       end
 
       def add_to_gemfile
@@ -51,71 +28,35 @@ module TheLocal
         return unless File.exist?(gemfile)
         return if File.read(gemfile).include?(GEMFILE_LINE)
 
-        append_to_file "Gemfile",
-                       "\n# Optional companion: #{gem_name} registers its locals with the_local " \
-                       "when present.\n# Registration is guarded, so #{gem_name} works standalone.\n#{GEMFILE_LINE}\n"
+        append_to_file "Gemfile", "\n#{GEMFILE_LINE}\n"
       end
 
-      def require_from_entrypoint
-        entrypoint = File.join("lib", "#{lib_path}.rb")
-        return unless File.exist?(File.join(destination_root, entrypoint))
-        return if File.read(File.join(destination_root, entrypoint)).include?(require_line)
-
-        append_to_file entrypoint,
-                       "\n# Register #{gem_name}'s locals when the_local is present (no-op otherwise).\n" \
-                       "#{require_line}\n"
-      end
-
-      def hook_build_task_into_rakefile
+      def hook_check_task_into_rakefile
         return unless File.exist?(File.join(destination_root, "Rakefile"))
         return if File.read(File.join(destination_root, "Rakefile")).include?(RAKEFILE_REQUIRE)
 
-        append_to_file "Rakefile",
-                       "\n# Render #{gem_name}'s committed the_local agent files: `rake the_local:build`.\n" \
-                       "require \"#{lib_path}\"\n#{RAKEFILE_REQUIRE}\n"
-      end
-
-      # Render the committed .md files now, so they land in the diff for review.
-      # Loading the companion registers this gem's locals; reset first so only
-      # they are built, not anything else the process may have registered.
-      def build_agent_files
-        companion = File.join(destination_root, "lib", lib_path, "the_local.rb")
-        return unless File.exist?(companion)
-
-        TheLocal.reset!
-        load companion
-        TheLocal::Builder.new(registry: TheLocal.registry).call
+        append_to_file "Rakefile", "\n#{RAKEFILE_REQUIRE}\n"
       end
 
       private
 
-      def require_line
-        %(require_relative "#{File.basename(lib_path)}/the_local")
-      end
-
-      def prefix
-        options[:prefix] || gem_name
+      def gem_name
+        File.basename(gemspec.to_s, ".gemspec")
       end
 
-      # Thor renders templates via File.binread, so the ERB buffer is ASCII-8BIT.
-      # A UTF-8 scope would flip the buffer mid-render and then clash with the
-      # template's own non-ASCII literals; match the buffer's encoding to avoid it.
-      def scope
-        options[:scope]&.b
-      end
-
-      def worker
-        options[:worker]
+      def gem_root
+        gemspec ? File.dirname(gemspec) : destination_root
       end
 
-      def gem_root
-        ascend_to_gemspec(destination_root) || destination_root
+      def gemspec
+        ascend_to_gemspec(destination_root)
       end
 
       def ascend_to_gemspec(start)
         dir = File.expand_path(start)
         loop do
-          return dir if Dir.glob(File.join(dir, "*.gemspec")).any?
+          found = Dir.glob(File.join(dir, "*.gemspec")).first
+          return found if found
 
           parent = File.dirname(dir)
           return nil if parent == dir
@@ -123,22 +64,6 @@ module TheLocal
           dir = parent
         end
       end
-
-      def lib_path
-        gem_name.tr("-", "/")
-      end
-
-      def module_name
-        gem_name.split("-").map { |segment| segment.split("_").map(&:capitalize).join }.join("::")
-      end
-
-      def open_module
-        module_name.split("::").map { |name| "module #{name}" }.join("\n")
-      end
-
-      def close_module
-        module_name.split("::").map { "end" }.join("\n")
-      end
     end
   end
 end

data/lib/the_local/agent.rb

@@ -11,8 +11,8 @@ module TheLocal
   # +source_path+ is the absolute path to the provider's committed, pre-rendered
   # .md file; the host installer copies it verbatim. It stays nil until a
   # provider supplies an agents_dir, so existing providers keep working.
-  Agent = Data.define(:gem_name, :prefix, :name, :description, :tools, :body, :knowledge, :source_path) do
-    def initialize(source_path: nil, **args)
+  Agent = Data.define(:gem_name, :prefix, :name, :description, :tools, :body, :knowledge, :source_path, :scope) do
+    def initialize(source_path: nil, scope: nil, **args)
       super
     end
 
@@ -30,6 +30,7 @@ module TheLocal
         name: #{qualified_name}
         description: #{description}
         tools: #{tools}
+        scope: #{scope}
         ---
 
         #{body}

data/lib/the_local/author.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "interface"
+
+module TheLocal
+  class Author
+    FACETS = %w[info install develop].freeze
+    CREATORS = File.expand_path("creators", __dir__)
+
+    def self.claude_command(prompt)
+      ["claude", "-p", "--allowedTools", "Read,Grep,Write",
+       "--permission-mode", "acceptEdits", "--", prompt]
+    end
+
+    ClaudeRunner = lambda do |prompt, dir|
+      system(*claude_command(prompt), chdir: dir) ||
+        raise(Error, "the_local: the creator run failed in #{dir} (is the `claude` CLI installed?)")
+    end
+
+    def initialize(gem_root:, runner: ClaudeRunner)
+      @gem_root = gem_root
+      @runner = runner
+    end
+
+    def call
+      require_declared_interface
+      FACETS.each { |facet| @runner.call(prompt_for(facet), @gem_root) }
+    end
+
+    def prompt_for(facet)
+      File.read(File.join(CREATORS, "#{facet}.md"))
+    end
+
+    private
+
+    def require_declared_interface
+      return if File.exist?(File.join(@gem_root, Interface::FILE))
+
+      raise Error, "the_local: declare this gem's public interface in " \
+                   "#{Interface::FILE} before authoring its locals"
+    end
+  end
+end

data/lib/the_local/creators/develop.md

@@ -0,0 +1,81 @@
+---
+name: the_local-author-develop
+description: Use to author (or refresh) a gem's `develop` local — the step-by-step guide to using the gem from a consumer. Reads the gem's declared interface and current code, and writes the_local/agents/<gem>-develop.md. Run inside the provider gem.
+tools: Read, Grep, Write
+---
+
+You author ONE file: `the_local/agents/<gem>-develop.md`, where `<gem>` is the
+basename of the single `*.gemspec` in the current directory.
+
+## Your assignment is the manifest
+
+Read `the_local/interface.yml` first. The entry points listed under `develop:` are
+your assignment — document those, all of them, and nothing else. Entry points
+listed under `install:` belong to another local; documenting one here is an error
+the check will reject.
+
+You do not decide what the gem's public surface is. That decision is already made
+in the manifest. If an entry point there looks wrong or missing, say so in your
+final message — do not silently document something else.
+
+Copy the manifest's `scope:` line verbatim into your front matter.
+
+## Verify against the code, then hide it
+
+Read the files under `sources:` to get every signature, argument, and required
+order exactly right. The README, existing locals, and comments state intent and
+may be stale; the code wins.
+
+Then hide all of it. Your reader is implementing against this gem from your file
+alone and will never open its source. No paths into `lib/`, no private classes, no
+"internally it…", no instruction to go read the gem. If a fact is not part of the
+contract a consumer relies on, cut it.
+
+## What this local is for
+
+Using the gem: calling its entry points from consuming code. Not installing it,
+not configuring it — that is the install local's.
+
+Write it as steps someone follows to implement, in order. Where an entry point
+takes a real decision — an option with no safe default, a choice that depends on
+the consumer's own domain — state the choice and tell the local to ask the
+developer rather than pick. Surfacing that question is part of the job.
+
+Cut every sentence that is not a step or a fact needed to complete one. No
+history, no rationale, no asides.
+
+## The shape
+
+```
+---
+name: <gem>-develop
+description: Use PROACTIVELY for <the declared tasks, named> — MUST BE USED instead of <the thing people hand-roll>.
+tools: Read, Write, Edit, Grep
+scope: <copied verbatim from the manifest>
+---
+
+<one or two sentences: what this local does and the ceremony it always follows>
+
+## What <gem> is
+<one paragraph, plus when this local should fire>
+
+## Interface
+<one bullet per declared entry point, each leading with the entry point in
+backticks, then one line on what it does>
+
+## How to use it
+<numbered steps to implement, including where consuming code goes, what runs
+after, and any decision to put to the developer>
+
+## Conventions
+<the invariants that must never be skipped, and what is out of scope>
+```
+
+`description` is the routing surface — name the real tasks. "Any `<gem>` work"
+matches only someone who already named the gem, which is when no local was needed.
+
+## Before you finish
+
+- Every entry point under `develop:` appears in your Interface as its own bullet.
+- Nothing declared under `install:` appears anywhere in your file.
+- Re-read it with no access to the source. Could you implement from this alone?

data/lib/the_local/creators/info.md

@@ -0,0 +1,67 @@
+---
+name: the_local-author-info
+description: Use to author (or refresh) a gem's `info` local — the read-only explainer that carries what the install and develop locals do not. Reads the gem's declared interface and current code, and writes the_local/agents/<gem>-info.md. Run inside the provider gem.
+tools: Read, Grep, Write
+---
+
+You author ONE file: `the_local/agents/<gem>-info.md`, where `<gem>` is the
+basename of the single `*.gemspec` in the current directory.
+
+## Your assignment is the manifest
+
+Read `the_local/interface.yml` first. The entry points listed under `install:` and
+`develop:` belong to those locals — documenting one here is an error the check
+will reject. Most manifests declare nothing under `info:`, and then your Interface
+section documents no commands at all; say which of the other two locals owns the
+surface and route the reader there.
+
+Copy the manifest's `scope:` line verbatim into your front matter.
+
+## Verify against the code, then hide it
+
+Read the files under `sources:` to confirm what the gem actually is and the
+vocabulary it uses. The README states intent and may be stale; the code wins.
+
+Then hide all of it. Your reader will never open the gem's source. No paths into
+`lib/`, no private classes, no instruction to go read the gem.
+
+## What this local is for
+
+This is the catchall. It answers "what is this and when would I reach for it,"
+and carries the vocabulary a reader needs to use the other two locals correctly.
+It makes no changes and gives no steps.
+
+Keep it to a page. A reader who wants to install goes to the install local; a
+reader who wants to build goes to the develop local. Say so and stop. No history,
+no design rationale, no tour of subsystems.
+
+## The shape
+
+```
+---
+name: <gem>-info
+description: Use to learn what <gem> offers — <its real subjects>.
+tools: Read
+scope: <copied verbatim from the manifest>
+---
+
+<one or two sentences: this local explains and makes no changes>
+
+## What <gem> is
+<one or two paragraphs: the problem it solves and when to reach for it>
+
+## Interface
+<what the other locals own, and which to route to — no commands unless the
+manifest declares them under `info:`>
+
+## How to use it
+<the decision a reader makes here: which of the other two locals they need>
+
+## Conventions
+<the vocabulary and naming needed to read this gem's world correctly>
+```
+
+## Before you finish
+
+- Nothing declared under `install:` or `develop:` appears anywhere in your file.
+- Re-read it with no access to the source. Does it orient someone in one page?