#>plans_surface

Working register

Plans & Horizons

I'm planning the next surfaces so you can enter, inspect, and keep going. A plan earns its place when it opens a door on this site — a route, a lab, or a setting — not when it names a folder.

Start with what is moving now. Owners live in the buckets. Verbs say what the work does. Relationships show what enables the next move.

#>plan_buckets

Plan Buckets

matrix

Pick a bucket, then open a live surface. GitHub is the ledger; the site is the proof.

Public Route, Proof & Genre Systems

active

Routes that prove the system in public. Walk the design hub, then play, then come back here.

design hub play rpg-portal
?"plans_now"

Now

First paint already holds. Open the lab to see cascade as priority. Atmosphere may arrive after you can read.

CSS Architecture

owner

A stylesheet should read as kinship: this child, the next sibling, a parent that :has() a kin. Layers decide who wins.

? css lab ~owner

First-paint spend

landed

Structure ships first. Grain, wonder, and ornament idle-load. Core 1623 KiB. A late restyle may only make a still page more itself.

#>home ~ledger

Portable kit

active

Take tokens and frames without the whole shell. Composition is the specimen, not the archive.

#>composition ~kit
?"verb_register"

Verb Register

A verb is a next action. Refine a meaning, build a surface, teach a route.

Refine

Clarify operator meaning, naming, behavior, and conceptual precision.

Build

Create surfaces, runtimes, tools, pages, and reusable structures.

Map

Expose relationships, symmetry, spatial address, discovery routes, and asset classification.

Integrate

Make SVG, runtime settings, images, gestures, and surfaces work coherently together.

Teach

Help visitors build fluency through explanation, repetition, and experience.

Stage

Control timing, pacing, cinematic reveal, and semantic emphasis over time.

Publish

Make plans, assets, operator pages, and media legible as public artifacts.

Adapt

Support mobile runtime, accessibility, settings, and user preference without losing coherence.

^"operator_semantics_plans"{

Operator Semantics & Lore

Plans that refine how operators work, what they mean, and how they become public surfaces rather than private theory.

Operator Semantics Refinement

foundation

Refine Spw operators so they remain true to the established lore and original set while leaving room for interpretation through symmetry, priming, and operator physics.

refine map teach
Feature Considerations:
  • Document operator lineage from original meaning to current implementation.
  • Explain physics: spatial acts, priming properties, interaction semantics.
  • Map symmetry: operator pairs, coherent dynamics, mirrored functions.
  • Clarify why some sequences feel inevitable once the physics is understood.
  • Show how interpretation emerges from structure rather than arbitrary rules.
Wonder Hook:

Operators are not arbitrary symbols. They are repeatable spatial and attentional relationships. Once that becomes visible, the language stops feeling invented and starts feeling discovered.

~full_plan ^semantics_document

Spw Operator Pages

active

Create a public atlas where each operator gets a stable page before it gets richer runtime behavior. The page should teach interaction semantics, metaphysics, brace physics, and symmetry through its own structure.

build teach publish
Feature Considerations:
  • One stable page per operator.
  • Sections for interaction, metaphysics, brace physics, and symmetry.
  • Operator-aware styling so the page demonstrates the operator through the medium itself.
  • Public discovery from home, software, and route navigation.
  • Stable URLs that can be referenced from other pages and future diagrams.
Wonder Hook:

The medium should teach the message. A reference operator page should feel referential in how it stages explanation and movement, not just in what it says.

~full_plan ^atlas
@"interaction_patterns"{

Interaction Patterns & Circuits

Plans that build satisfying circuits, reward familiarity, and make interaction semantics easier to learn over time.

Interaction Grammar

active

Develop practical interactive circuits that become satisfying and familiar over time. Rethink brace physics vocabulary toward something cognitively accessible while preserving spatial relationship practice.

build teach adapt
Feature Considerations:
  • Entry → practiced → fluent → habitual progression.
  • Brace physics vocabulary audit and accessibility review.
  • Subtle familiarity feedback that does not feel gamified.
  • Runtime recognition of repeated user circuit preferences.
  • Touch-native circuits that still honor operator priming.
Wonder Hook:

Depth should emerge from familiarity. The site becomes something a visitor can learn to play, not just inspect once.

~full_plan ^semantics

Cinematic Handles

merged reference

Research reference for semantic timing; active motion and timing work routes through Color & Motion.

stage integrate adapt
Feature Considerations:
  • Named timing tokens for small, medium, and full reveals.
  • Attention curves for ambient vs. addressed components.
  • Cross-element transition composition.
  • Screenshot pause moments where semantic intent is legible.
  • User-adjustable pacing sensitivity through settings.
Wonder Hook:

Motion becomes meaningful when it has a role. Timing can communicate relation, emphasis, caution, invitation, or readiness.

~source_reference ~active_owner

Cognitive Navigation

split reference

Design navigation that builds cognitive maps. Users should understand where they are, how they got there, and how to return without depending on external breadcrumbs alone.

map build teach
Feature Considerations:
  • Spatial address and frame hierarchy.
  • Local ground as always-available return point.
  • Surface map for visual layout understanding.
  • Wayfinding affordances that do not depend on prior expertise.
  • Reduced cognitive load while still teaching structure.
Wonder Hook:

The site becomes navigable like a building: familiar rooms, repeated landmarks, and confidence that structure can be learned.

~full_plan
*"platform_horizons"{

Platform Horizons & Features

Plans that expand what the site can do operationally: assets, mobile runtime, RPG tooling, pretext lab, and settings.

Semantic Asset Management

foundation

Organize images and assets by purpose and surface with sidecar `.spw` metadata so assets become discoverable semantic participants instead of anonymous files.

map integrate publish
Feature Considerations:
  • Surface-specific organization for images and media.
  • Sidecar metadata: spirit name, mapping, optimization record.
  • Optimization pipeline with multiple output tiers.
  • Discoverable asset registry.
  • Naming system that helps images become addressable content.
Wonder Hook:

An image should not just exist on disk. It should have a name, a surface, a role, and a reason to be discoverable later.

^conventions @naming_magic_skill

Mobile Runtime Foundation

split reference

Build a mobile-first runtime that keeps interaction semantics intact on small screens instead of collapsing the site into reduced desktop leftovers.

adapt build integrate
Feature Considerations:
  • Touch gestures mapped to operator interaction.
  • Viewport discipline and chrome decisions.
  • Progressive disclosure for small screens.
  • Spatial address maintained on mobile.
  • Battery and connection-aware performance defaults.
Wonder Hook:

The site should transform for mobile rather than merely shrink. Structure should survive the change in modality.

~full_plan

RPG Local Gameplay

active

Build a local-first RPG table tool with session state, character sheets, dice, and encounter handling that remains usable without a server.

build adapt publish
Feature Considerations:
  • Local-only session state.
  • Character and creature support surfaces.
  • Encounter runner and initiative logic.
  • Dice systems and roll history.
  • Screenshot-ready interaction moments.
Wonder Hook:

The tool should disappear into play. Reliability becomes part of the atmosphere.

^gameplay_surface ~full_plan

Pretext & Whimsy Lab

planning

Create a lab for mathematics, physics, notation, and code framed through Spw’s spatial grammar so other languages can shine more clearly rather than be replaced.

build teach integrate
Feature Considerations:
  • Multi-language surfaces for math, code, and notation.
  • Discovery exercises taught through spatial play.
  • Notation comparisons that reveal structure.
  • Whimsy without loss of rigor.
  • Physics visualization as explanatory support.
Wonder Hook:

The lab is where rigor and play meet. It should make formal systems feel more inhabitable.

~full_plan

Runtime Settings & Customization

foundation

Give users granular control over appearance, accessibility, visibility, developer surfaces, and performance without forcing immediate configuration burdens.

adapt integrate teach
Feature Considerations:
  • Accessibility settings.
  • Appearance and color behavior.
  • Developer/debug visibility.
  • Typography controls.
  • Performance and lazy-loading preferences.
Wonder Hook:

Defaults should be calm, but control should exist for people who want to inspect, tune, or quiet the environment.

@settings ~full_plan
~"supporting_plans"{

Supporting Plans

Foundations that stay useful after the current cut. Open a route when the plan names one.

Media Publishing Register

foundation

What this week is about, in public. Use it when a conversation needs one featured surface.

publishmap
~full_plan

Screenshot Semantics

planning

A still frame should still explain itself. Capture from settings when you need a shareable proof.

stagepublish
~full_plan

SVG Surface Integration

planning

A diagram should carry the same tokens as type. Open the SVG lab when a picture needs an address.

? svg lab ~ledger

PWA Experience

foundation

The page should remain after the tab closes. Install is a courtesy, not the product.

adaptbuild
~full_plan

Agent Optimization

active

The next session should cost less discovery than the last. This page is part of that surface.

maprefine
~full_plan @plan_maintenance
*"plan_relationships"{

Plan Relationships

One plan should open another. Follow the link, not the folder name.

Semantics first

Operator meaning supports public operator pages. Read the lore, then try a chip on the Spw topic.

Navigation and pacing

How a route teaches its own next step. Timing work lives in now; motion tokens stay in color-motion.

Assets and SVG

Pictures that can be addressed. Open the SVG lab when a diagram should carry the same tokens as type.

Runtime adaptation

The page should stay usable when the network is thin. Tune in settings; install is a later courtesy.

Cascade is not delivery

The CSS rail owns who wins. The spend-cut owns who arrives. JS mount is a sibling. Reordering @layer does not shrink the bundle. See now.

Publishing and capture

Media Publishing Register and Screenshot Semantics support discussion, sharing, and public explanation.

Play surfaces

RPG Local Gameplay and Pretext & Whimsy Lab support applied experimentation and learning through interaction.

?"plan_discovery"{

Plan Discovery & Use

What is a plan?

A plan is a structured document for a feature consideration or brand horizon. It should be usable as guidance, not just archival prose.

What do the statuses mean?

  • Foundation: conceptually strong and ready to guide implementation
  • Active: being developed or refined now
  • Planning: the direction is set, but not yet underway
  • Merged reference: source context is retained; active work routes to the named owner
  • Implemented reference: a landed contract retained for citations, not an active queue
  • Split reference: the umbrella is retained; concrete work routes to narrower owners

What should improve later?

The next step is visual structure: better surface styling, verb-aware filtering, plan relationship diagrams, and a more legible semantic map.

Where are the source files?

Full plan documents live in the GitHub repository under `.agents/plans/...`, and related `.spw` files live in the same repo where applicable.