Template compounder

Every output becomes a reusable starting point.

Templates capture the prompt, inputs, acceptance checks, risk notes, remix instructions, and visible proof artifact behind each skill. The daily loop is designed to leave behind one previewable asset in each business lane, not just a one-off answer.

Weak provider-fallback runs and same-day governed template lanes should not define the product surface. When the latest live output is still generic, OWOJI keeps the reusable template structure visible while the gallery points users at clearer proof examples.

Forkable skills

Markdown skills for agents, sub-agents, and future MCP calls, each paired with the thing it produces.

Launch assets

Pages, emails, scripts, slide/carousel content, release notes, and outreach sequences.

Design briefs

Brand systems, UI previews, dashboard cards, motion briefs, and CAD/product specs.

Feedback loop

Users can report gaps; OWOJI tracks feedback and schedules improvement jobs.

skillstemplate payload

Skill template

When to use it, required inputs, workflow steps, safety checks, output schema, evaluation rubric, and sample output.

web / apptemplate payload

Screen template

Purpose, information hierarchy, layout system, interaction states, accessibility notes, and preview scaffolding.

contenttemplate payload

Launch template

Audience, offer framing, hooks, emails, slides, copy blocks, channels, objections, and reuse instructions.

business / datatemplate payload

Research dashboard template

Market frame, user pain, monetization logic, KPI cards, risk register, experiments, and next operator actions.

motion / cadtemplate payload

Production brief template

Objective, scene or geometry structure, constraints, required assets, storyboard frames, and handoff notes for execution.

scout additionskill garden

Browser ops bundle template

Package repeated browser work as one OWOJI-ready bundle: a SKILL.md entry file, a references/ folder for selectors, policy notes, and examples, optional validator scripts for deterministic checks, a typed tool schema, an explicit invocation-policy block, a visible structured_output contract, explicit session or auth handles, and an evidence manifest tied to a proof artifact.

Starter fields
bundle:
  entry_skill: SKILL.md
  references:
    - intent.md
    - selectors.md
    - policy.md
    - examples.md
  scripts:
    - validate-output.ts
  assets:
    - evidence-manifest.json
  invocation_policy:
    mode: auto-or-manual
    argument_hint: "[goal] [start_url]"
    allowed_tools:
      - browser
      - screenshot
    disallowed_tools:
      - external_publish
    context: inline-or-fork
  tool_schema:
    name: browser_ops_bundle
    input_schema: { type: object, required: [goal, start_url] }
  prompt_surface:
    launcher: /run-browser-skill
  context_surface:
    resources:
      - docs
      - examples
      - policy
  browser_state_policy:
    profile_mode: saved-state-or-clean-login
    locator_bootstrap: prefer-playwright-codegen-then-normalize
    locator_policy: prefer_roles_labels_testids
  output:
    structured_output: required
    evidence_manifest: required
    explicit_handles:
      - auth_state_ref
      - browser_session_ref
      - trace_ref
    resource_links:
      - evidence://latest-screenshot
      - selectors://current-page
  evals:
    - required fields returned
    - validator script passes
    - approval boundary respected
    - evidence attached
scout additiontyped outputs

Data tool + render template

When one skill needs both reusable structured data and a polished preview, split the contract. The data tool returns complete machine-usable output with an explicit outputSchema; the render step consumes that prepared payload and produces the widget, preview, or proof artifact.

Starter fields
compound_template:
  data_tool:
    name: browser_ops_data
    output_schema: required
    returns:
      - structured_output
      - handles
      - resource_links
  render_step:
    name: browser_ops_render
    accepts:
      - prepared_data
      - proof_context
    returns:
      - widget_or_preview
      - proof_artifact
    rule: no new business logic
  evals:
    - output schema validates before render
    - render step consumes prepared data only
    - proof artifact matches structured output
scout additionoutput contract

Explicit-handle output contract template

Return one model-safe payload plus explicit runtime handles and resource links. The visible side stays strict with structuredContent and proof artifacts, while auth/session references, trace ids, or browser-profile pointers move into handle fields the model can reason about without exposing secrets inline.

Starter fields
contract:
  output_schema:
    type: object
    required:
      - result
      - evidence
  structured_output:
    result: visible model-safe payload
    evidence:
      - screenshot
      - summary
      - resource_link
  handles:
    auth_state_ref: opaque handle
    browser_session_ref: opaque handle
    trace_ref: opaque handle
    cache_ref: opaque handle
  tool_result:
    resource_links:
      - uri: evidence://run/{run_id}/latest
      - uri: selectors://{site}/{page}
  resource_templates:
    - uri_template: skill://docs/{account}/{path}
    - uri_template: skill://selectors/{site}/{page}
  rules:
    - never expose secrets in structured output
    - validate structured output against schema
    - persist or rotate auth state by policy
    - pass handles or resource links instead of hidden metadata

Public gallery data fills these shells when live outputs are published. Until then, the structure and proof examples stay visible so users can understand how private daily runs compound into remixable templates.