@jenga-ai/agent 2.0.0 → 3.0.0

package/skills/init/assets/workflow_template.json

@@ -1,30 +0,0 @@
-{
-  "statuses": ["Pending", "In Progress", "Passed", "Passed with remarks", "Failed", "Rejected", "Blocked"],
-  "rapport_types": ["conflict", "implementation_blocker", "security_concern", "test_failure", "analysis"],
-  "paths": {
-    "board": "project/board",
-    "epics": "project/board/epics",
-    "stories": "project/board/stories",
-    "tasks": "project/board/tasks",
-    "rapports_problems": "project/rapports/problems",
-    "rapports_analysis": "project/rapports/analysis",
-    "queue": "project/queue",
-    "scrum_triggers": "project/queue/scrum_triggers.jsonl",
-    "developer_triggers": "project/queue/developer_triggers.jsonl",
-    "tester_triggers": "project/queue/tester_triggers.jsonl",
-    "session_handoff": "project/queue/handoffs/",
-    "logs": "project/logs",
-    "data": "project/data",
-    "configs": "project/configs",
-    "documentation": "project/documentation",
-    "documentation_plans": "project/documentation/plans",
-    "documentation_summaries": "project/documentation/summaries"
-  },
-  "agents": ["developer", "tester", "scrum-master"],
-  "pipeline": [
-    {"step": 1, "agent": "scrum-master", "phase": "planning",        "on_complete": "write planning_complete handoff → developer_triggers.jsonl"},
-    {"step": 2, "agent": "developer",    "phase": "implementation",  "on_complete": "write implementation_complete handoff → tester_triggers.jsonl"},
-    {"step": 3, "agent": "tester",       "phase": "verification",    "on_complete": "write test status handoff → scrum_triggers.jsonl (+ developer_triggers.jsonl if failed)"},
-    {"step": 4, "agent": "scrum-master", "phase": "rollup_review",   "on_complete": "update board statuses, close epic/story if all done"}
-  ]
-}

package/skills/init/scripts/apply-project-visibility.sh

@@ -1,176 +0,0 @@
-#!/usr/bin/env bash
-#
-# apply-project-visibility.sh — apply the `project_files_visibility` mode to a project.
-#
-# Usage:
-#   apply-project-visibility.sh <mode> [project_root]
-#   apply-project-visibility.sh --check-only <mode>
-#
-# Modes:
-#   visible   Working files stay where they are. No-op on disk beyond the config write.
-#   ignored   Working files are added to the project's .gitignore — present on disk,
-#             never committed.
-#
-# NOTE: A third mode, `hidden` (dot-prefixing project/ -> .project/), was
-# implemented and then withdrawn before release. Testing found it functionally
-# broken: scripts/board_resolver.sh hardcodes project/configs/workflow.json
-# and never locates the rewritten path, and hooks/on_session_end.sh
-# unconditionally recreates a shadow project/ tree on every session end,
-# splitting runtime state across two trees. See
-# project/rapports/problems/E31_S05_T01-hidden-mode-path-resolution-gaps.md
-# for the full findings. Re-introducing `hidden` requires fixing both of
-# those hardcoded paths first — tracked as a follow-up /todo item.
-#
-# Exit codes:
-#   0  Success
-#   1  Bad usage or missing prerequisite
-#   2  Invalid mode (outside the two-value enum)
-#   3  Filesystem apply failure
-#   4  jenga.config.json write failure
-
-# Do NOT use set -e globally — each step handles its own errors.
-set -uo pipefail
-
-info() { echo "[visibility] $*"; }
-warn() { echo "[visibility] WARNING: $*"; }
-err()  { echo "[visibility] ERROR: $*" >&2; }
-
-usage() {
-  echo "Usage: $(basename "$0") <visible|ignored> [project_root]" >&2
-  echo "       $(basename "$0") --check-only <visible|ignored>" >&2
-  exit 1
-}
-
-# Every Jenga AI working file named in E31_S05 — the scrum board, todo.md,
-# queue/, rapports/ and logs/ — nests under this single root, so one entry
-# covers them all. `ignored` consumes this list.
-JENGA_WORKING_PATHS=("project")
-
-VALID_MODES="visible ignored"
-
-validate_mode() {
-  local mode="$1"
-  for valid in $VALID_MODES; do
-    [ "$mode" = "$valid" ] && return 0
-  done
-  err "Invalid project_files_visibility value: '${mode}'"
-  err "Allowed values are: ${VALID_MODES// /, }"
-  exit 2
-}
-
-# ---------------------------------------------------------------------------
-# Argument parsing
-# ---------------------------------------------------------------------------
-
-CHECK_ONLY=0
-if [ "${1:-}" = "--check-only" ]; then
-  CHECK_ONLY=1
-  shift
-fi
-
-MODE="${1:-}"
-[ -n "$MODE" ] || usage
-
-validate_mode "$MODE"
-
-if [ "$CHECK_ONLY" -eq 1 ]; then
-  info "Mode '$MODE' is valid."
-  exit 0
-fi
-
-PROJECT_ROOT="${2:-$PWD}"
-if [ ! -d "$PROJECT_ROOT" ]; then
-  err "Project root does not exist: $PROJECT_ROOT"
-  exit 1
-fi
-cd "$PROJECT_ROOT" || { err "Cannot enter project root: $PROJECT_ROOT"; exit 1; }
-
-if ! command -v jq >/dev/null 2>&1; then
-  err "jq is required to write jenga.config.json but was not found on PATH."
-  exit 1
-fi
-
-# ---------------------------------------------------------------------------
-# ignored — append to .gitignore, without ever duplicating an entry
-# ---------------------------------------------------------------------------
-
-gitignore_append() {
-  local entry="$1"
-  local gitignore=".gitignore"
-
-  if [ -f "$gitignore" ] && grep -qxF -- "$entry" "$gitignore"; then
-    info "'$entry' already present in .gitignore — skipping."
-    return 0
-  fi
-
-  # Don't glue our entry onto a final line that lacks a newline.
-  if [ -s "$gitignore" ] && [ -n "$(tail -c 1 "$gitignore")" ]; then
-    printf '\n' >> "$gitignore"
-  fi
-
-  if ! printf '%s\n' "$entry" >> "$gitignore"; then
-    err "Failed to append '$entry' to .gitignore"
-    exit 3
-  fi
-  info "Added '$entry' to .gitignore"
-}
-
-# ---------------------------------------------------------------------------
-# jenga.config.json — merge the field in, written atomically (temp + mv)
-# ---------------------------------------------------------------------------
-
-write_visibility_config() {
-  local mode="$1"
-  local config="jenga.config.json"
-  local tmp="${config}.tmp"
-  local existing='{}'
-
-  # /init normally runs before any /distribute, so the file usually does not
-  # exist yet. Merge rather than overwrite so other fields survive.
-  if [ -f "$config" ]; then
-    if ! jq empty "$config" 2>/dev/null; then
-      err "$config exists but contains malformed JSON — refusing to overwrite it."
-      exit 4
-    fi
-    existing="$(cat "$config")"
-  fi
-
-  local content
-  content="$(jq --arg v "$mode" '.project_files_visibility = $v' <<< "$existing")"
-  if [ -z "$content" ]; then
-    err "Failed to construct $config content."
-    exit 4
-  fi
-
-  if ! printf '%s\n' "$content" > "$tmp"; then
-    err "Failed to write temporary config file: $tmp"
-    exit 4
-  fi
-
-  if ! mv "$tmp" "$config"; then
-    err "Failed to atomically move $tmp to $config"
-    rm -f "$tmp"
-    exit 4
-  fi
-
-  info "Wrote project_files_visibility = \"$mode\" to $config"
-}
-
-# ---------------------------------------------------------------------------
-# Apply
-# ---------------------------------------------------------------------------
-
-case "$MODE" in
-  visible)
-    info "Mode 'visible' — working files stay in place; nothing to change on disk."
-    ;;
-  ignored)
-    for path in "${JENGA_WORKING_PATHS[@]}"; do
-      gitignore_append "${path}/"
-    done
-    ;;
-esac
-
-write_visibility_config "$MODE"
-
-info "Applied project_files_visibility '$MODE' to $PROJECT_ROOT"

package/skills/init/scripts/detect-existing-codebase.sh

@@ -1,166 +0,0 @@
-#!/usr/bin/env bash
-# ---------------------------------------------------------------------------
-# skills/init/scripts/detect-existing-codebase.sh
-#
-# Deterministic front half of the /init "detect existing project state" step.
-# /init currently always scaffolds as though the target directory were empty.
-# That is wrong whenever a directory already carries a Jenga scaffold, or
-# already carries substantial application code that predates Jenga entirely
-# -- in the second case, scaffolding fresh produces an empty board and a stub
-# PROJECT_SUMMARY.md that actively misrepresent the project.
-#
-# This script answers exactly one question -- "what kind of directory is
-# this?" -- and nothing else. It never scaffolds, never prompts, never runs
-# /uncharted, and never modifies anything on disk. Deciding what to DO with
-# the verdict is agent judgement and lives in skills/init/SKILL.md.
-#
-# ---------------------------------------------------------------------------
-# VERDICTS -- exactly one is printed on stdout, nothing else
-# ---------------------------------------------------------------------------
-#   empty               The target is empty, or contains only boilerplate
-#                       that does not count as "there is a project here":
-#                       .git (the directory itself, pruned entirely -- not
-#                       merely excluded by name), .gitignore, and top-level
-#                       README*/LICENSE*/LICENCE* files (case-insensitive),
-#                       plus anything git itself reports as ignored. A repo
-#                       containing only a README is empty for this purpose.
-#   already-scaffolded  The target already carries a Jenga scaffold: any one
-#                       of project/board/, project/PROJECT_SUMMARY.md, or
-#                       project/configs/workflow.json is present. Checked
-#                       BEFORE the emptiness scan, so a scaffolded project
-#                       that also happens to look sparse is never misreported
-#                       as "empty".
-#   existing-codebase   The target has real content (source files, configs,
-#                       docs beyond the boilerplate list above, etc.) and is
-#                       not already Jenga-scaffolded. This is the case /init
-#                       currently mishandles: scaffolding fresh here silently
-#                       discards the fact that pre-existing code exists.
-#
-# ---------------------------------------------------------------------------
-# NOTES ON GITIGNORE HANDLING
-# ---------------------------------------------------------------------------
-# /init runs this check BEFORE `git init` in the fresh-scaffold path, so the
-# target directory is very often not a git work tree yet. Gitignore-based
-# filtering is therefore best-effort: it only runs when the target already
-# has a `.git` directory AND `git` is on PATH. A standalone `.gitignore` file
-# with no repository behind it still counts as boilerplate via the name-based
-# exclusion below -- it just cannot hide any OTHER file, because there is no
-# git to ask "is this ignored".
-#
-# README/LICENSE exclusion applies to TOP-LEVEL entries only. A directory
-# whose only content is a buried `docs/README.md` two levels down is real
-# structure, not boilerplate, and must not be reported as empty.
-#
-# ---------------------------------------------------------------------------
-# Usage
-# ---------------------------------------------------------------------------
-#   detect-existing-codebase.sh [target-dir]
-#
-#   target-dir   Directory to classify. Default: current directory.
-#
-# Options:
-#   -h, --help   Show this help and exit 0.
-#
-# Exit codes:
-#   0   A verdict was printed on stdout.
-#   1   Usage error (unknown option, more than one positional argument).
-#   2   target-dir does not exist or is not a directory.
-#
-# Requires: bash, find. git is used opportunistically for gitignore
-# filtering when the target is already a git work tree; its absence never
-# causes a failure.
-# ---------------------------------------------------------------------------
-
-set -euo pipefail
-
-SELF="$(basename "$0")"
-
-usage() {
-  sed -n '/^# Usage$/,/^# Requires:/p' "$0" | sed -e 's/^# \{0,1\}//' -e '/^-\{10,\}$/d'
-}
-
-die_usage() {
-  printf '%s: error: %s\n' "$SELF" "$*" >&2
-  echo >&2
-  usage >&2
-  exit 1
-}
-
-TARGET_DIR="."
-HAVE_TARGET=0
-
-while [ "$#" -gt 0 ]; do
-  case "$1" in
-    -h|--help) usage; exit 0 ;;
-    --)
-      shift
-      [ "$#" -le 1 ] || die_usage "at most one target directory is allowed"
-      if [ "$#" -eq 1 ]; then TARGET_DIR="$1"; HAVE_TARGET=1; fi
-      shift $#
-      ;;
-    -*)
-      die_usage "unknown option \"$1\"" ;;
-    *)
-      [ "$HAVE_TARGET" -eq 0 ] || die_usage "at most one target directory is allowed (got \"$TARGET_DIR\" and \"$1\")"
-      TARGET_DIR="$1"; HAVE_TARGET=1; shift ;;
-  esac
-done
-
-[ -d "$TARGET_DIR" ] || { printf '%s: error: not a directory: %s\n' "$SELF" "$TARGET_DIR" >&2; exit 2; }
-
-TARGET_DIR="$(cd -- "$TARGET_DIR" && pwd -P)"
-
-# --- already-scaffolded: checked first, independent of emptiness -----------
-if [ -d "$TARGET_DIR/project/board" ] \
-   || [ -f "$TARGET_DIR/project/PROJECT_SUMMARY.md" ] \
-   || [ -f "$TARGET_DIR/project/configs/workflow.json" ]; then
-  echo "already-scaffolded"
-  exit 0
-fi
-
-# --- enumerate candidate files, pruning .git entirely -----------------------
-ALL_FILES=$(mktemp "${TMPDIR:-/tmp}/detect-existing-codebase.XXXXXX")
-IGNORED_FILES=$(mktemp "${TMPDIR:-/tmp}/detect-existing-codebase-ignored.XXXXXX")
-cleanup() { rm -f "$ALL_FILES" "$IGNORED_FILES"; }
-trap cleanup EXIT
-
-find "$TARGET_DIR" -path "$TARGET_DIR/.git" -prune -o -type f -print > "$ALL_FILES"
-
-# --- best-effort gitignore filtering ----------------------------------------
-: > "$IGNORED_FILES"
-if [ -d "$TARGET_DIR/.git" ] && command -v git >/dev/null 2>&1; then
-  git -C "$TARGET_DIR" check-ignore --stdin < "$ALL_FILES" > "$IGNORED_FILES" 2>/dev/null || true
-fi
-
-# --- classify each candidate -------------------------------------------------
-SOURCE_FOUND=0
-while IFS= read -r f; do
-  [ -n "$f" ] || continue
-
-  if [ -s "$IGNORED_FILES" ] && grep -Fxq -- "$f" "$IGNORED_FILES"; then
-    continue
-  fi
-
-  rel="${f#"$TARGET_DIR"/}"
-  base="$(basename -- "$f")"
-  dir_rel="$(dirname -- "$rel")"
-
-  if [ "$dir_rel" = "." ]; then
-    if [ "$base" = ".gitignore" ]; then
-      continue
-    fi
-    base_upper="$(printf '%s' "$base" | tr '[:lower:]' '[:upper:]')"
-    case "$base_upper" in
-      README*|LICENSE*|LICENCE*) continue ;;
-    esac
-  fi
-
-  SOURCE_FOUND=1
-  break
-done < "$ALL_FILES"
-
-if [ "$SOURCE_FOUND" -eq 1 ]; then
-  echo "existing-codebase"
-else
-  echo "empty"
-fi

package/skills/init/scripts/init.sh

@@ -1,116 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-ASSETS_DIR="$SCRIPT_DIR/../assets"
-VISIBILITY_SCRIPT="$SCRIPT_DIR/apply-project-visibility.sh"
-
-# ─── Resolve the package root that owns templates/ and lib/ ──────────────────
-# postinstall.js mirrors only skills/ and agents/ into .claude/ and .agents/ —
-# templates/ and lib/ are never copied there, so a script running from a
-# mirrored copy (.claude/skills/init/scripts/ or .agents/skills/init/scripts/)
-# cannot reach its siblings via a fixed ../../../ climb the way it can in this
-# monorepo checkout, where init.sh actually lives at skills/init/scripts/ with
-# templates/ and lib/ three levels up. Consumers instead have them inside the
-# installed npm package.
-if [[ -d "$SCRIPT_DIR/../../../templates" ]]; then
-  PKG_ROOT="$SCRIPT_DIR/../../.."
-elif [[ -d "$PWD/node_modules/@jenga-ai/agent/templates" ]]; then
-  PKG_ROOT="$PWD/node_modules/@jenga-ai/agent"
-else
-  echo "Error: could not locate the jenga-agent package root (templates/ not found via monorepo checkout or node_modules/@jenga-ai/agent)." >&2
-  exit 1
-fi
-
-# ─── 0. Resolve project_files_visibility ─────────────────────────────────────
-# Defaults to `visible` — the only value that touches nothing on disk — so an
-# unattended run can never silently relocate directories or edit .gitignore.
-VISIBILITY="${JENGA_PROJECT_FILES_VISIBILITY:-visible}"
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --visibility)   VISIBILITY="${2:-}"; shift 2 ;;
-    --visibility=*) VISIBILITY="${1#*=}"; shift ;;
-    *) echo "Unknown argument: $1" >&2
-       echo "Usage: $(basename "$0") [--visibility <visible|ignored>]" >&2
-       exit 1 ;;
-  esac
-done
-
-# Validate before scaffolding so a typo cannot leave a half-initialised project.
-bash "$VISIBILITY_SCRIPT" --check-only "$VISIBILITY"
-
-# ─── 1. Initialize git repository ────────────────────────────────────────────
-echo "→ Initializing git repository..."
-git init
-
-# ─── 2. Create .gitignore ─────────────────────────────────────────────────────
-echo "→ Copying .gitignore from template..."
-cp "$ASSETS_DIR/.gitignore_template" .gitignore
-
-# ─── 3. Scaffold directory structure ──────────────────────────────────────────
-echo "→ Scaffolding directory structure..."
-while IFS= read -r dir || [[ -n "$dir" ]]; do
-  [[ -z "$dir" || "$dir" == \#* ]] && continue
-  mkdir -p "$dir"
-done < "$ASSETS_DIR/directory_structure.txt"
-
-# ─── 4. Create project/PROJECT_SUMMARY.md ────────────────────────────────────
-echo "→ Copying PROJECT_SUMMARY.md from template..."
-cp "$ASSETS_DIR/PROJECT_SUMMARY_template.md" project/PROJECT_SUMMARY.md
-
-# ─── 5. Create project/configs/workflow.json ─────────────────────────────────
-echo "→ Copying workflow.json from template..."
-cp "$ASSETS_DIR/workflow_template.json" project/configs/workflow.json
-
-# ─── 6. Create project/configs/test-config.json stub ─────────────────────────
-echo "→ Copying test-config.json from template..."
-cp "$ASSETS_DIR/test-config_template.json" project/configs/test-config.json
-
-# ─── 6.5. Create project/configs/scope-thresholds.json ───────────────────────
-# Consumed by skills/jenga (Phase 0) and skills/do (Step 0); both halt if it's
-# missing, so it must exist immediately after scaffold.
-echo "→ Copying scope-thresholds.json from template..."
-cp "$ASSETS_DIR/scope-thresholds_template.json" project/configs/scope-thresholds.json
-
-# ─── 7. Create project/data/baselines.json ───────────────────────────────────
-echo "→ Creating baselines.json..."
-echo '{}' > project/data/baselines.json
-
-# ─── 8. Create project/logs/events.json ──────────────────────────────────────
-echo "→ Creating events.json..."
-echo '[]' > project/logs/events.json
-
-# ─── 9. Create docs/STRATEGY.md ──────────────────────────────────────────────
-echo "→ Creating docs/STRATEGY.md (strategic brief for investors, partners, and the product team)..."
-mkdir -p docs
-cp "$ASSETS_DIR/strategy_stub_template.md" docs/STRATEGY.md
-
-# ─── 10. Create CHANGELOG.md ──────────────────────────────────────────────────
-echo "→ Creating CHANGELOG.md from template..."
-cp "$PKG_ROOT/templates/CHANGELOG_TEMPLATE.md" CHANGELOG.md
-
-# ─── 11. Apply project_files_visibility ──────────────────────────────────────
-# Runs before the commit so the .gitignore entry (ignored) is captured in the
-# initial commit.
-echo "→ Applying project files visibility ($VISIBILITY)..."
-bash "$VISIBILITY_SCRIPT" "$VISIBILITY" "$PWD"
-
-# ─── 12. Generate CLAUDE.md / AGENTS.md ──────────────────────────────────────
-# Unconditional — never gated on agentTarget (E41_S04). Applies the J-
-# collision rule and idempotent managed-block updates; see
-# lib/generate-agent-context.js (shared with the published `jenga init` CLI).
-echo "→ Generating CLAUDE.md / AGENTS.md..."
-if command -v node >/dev/null 2>&1; then
-  node "$PKG_ROOT/lib/generate-agent-context.js" "$PWD"
-else
-  echo "  Warning: node not found — skipped CLAUDE.md/AGENTS.md generation." >&2
-fi
-
-# ─── 13. Initial commit ──────────────────────────────────────────────────────
-echo "→ Staging and committing scaffolded files..."
-git add -A
-git commit -m "init: scaffold project structure and workflow config"
-
-echo ""
-echo "✓ Project scaffold complete."

package/skills/jbp/SKILL.md

@@ -1,25 +0,0 @@
----
-name: j:jbp
-description: Scaffold the project using the JengaBasePlate boilerplate repo template from https://github.com/samwelmunga/JengaBasePlate.git
-keywords:
-  - jbp
-  - boilerplate
-  - scaffold
-  - template
-  - jenga base
-examples:
-  - "scaffold with JengaBasePlate"
-  - "set up the base template"
----
-
-# JBP — JengaBasePlate Scaffold
-
-## Instructions
-
-Use the following repo as the boilerplate framework for this project:
-
-```
-https://github.com/samwelmunga/JengaBasePlate.git
-```
-
-Clone or pull the template and apply its structure to the current project.

package/skills/lgtm/SKILL.md

@@ -1,21 +0,0 @@
----
-name: j:lgtm
-description: Approve and commit the current work, then continue to the next task. Shortcut that chains /commit followed by /continue.
-keywords:
-  - lgtm
-  - approve
-  - looks good
-  - done
-  - commit and continue
-examples:
-  - "lgtm, commit this"
-  - "looks good, move on"
----
-
-# LGTM — Approve, Commit, and Continue
-
-## Instructions
-
-1. Invoke the `/commit` skill and wait for it to finish.
-
-2. If the current workflow is part of a `/do` execution, return to that workflow. Otherwise, invoke the `/continue` skill.

package/skills/skillify/assets/init-new/assets/.gitignore_template

@@ -1,15 +0,0 @@
-# macOS & Windows system files
-.DS_Store
-Thumbs.db
-Desktop.ini
-
-# Environment files
-.env
-.env.*
-*.local
-
-# Dependency directories
-node_modules/
-vendor/
-.venv/
-EOF

package/skills/skillify/assets/init-new/assets/PROJECT_SUMMARY_template.md

@@ -1,13 +0,0 @@
-# Project Summary
-
-## Overview
-_To be completed._
-
-## Architecture & Structure
-_To be completed._
-
-## Epics
-_To be completed via /pi-plan._
-
-## Conventions
-_To be completed._

package/skills/skillify/assets/init-new/assets/directory_structure.txt

@@ -1,14 +0,0 @@
-project/board/epics
-project/board/stories
-project/board/tasks
-project/instructions
-project/configs
-project/data
-project/queue
-project/rapports/problems
-project/rapports/analysis
-project/logs
-project/documentation
-project/documentation/plans
-project/documentation/summaries
-project/documentation/examples

package/skills/skillify/assets/init-new/assets/test-config_template.json

@@ -1,4 +0,0 @@
-{
-  "_note": "Run the tester agent to configure tools for this project.",
-  "tools": []
-}

package/skills/wtf/SKILL.md

@@ -1,20 +0,0 @@
----
-name: j:wtf
-description: Alias of /clearify — clarifies ambiguous, dense, or under-specified prompts and conversation on request. This folder exists only so the `/wtf` slash command resolves to a skill; behaviour is identical to `/clearify`.
-keywords:
-  - wtf
-  - confused
-  - huh
-  - what does this mean
-  - I'm lost
-examples:
-  - "wtf"
-  - "wtf does this mean"
-  - "wtf is going on here"
----
-
-# WTF — Alias of /clearify
-
-## Instructions
-
-`/wtf` is an alias of `/clearify`. Follow `skills/clearify/SKILL.md` in full — do not duplicate or reimplement its ambiguity-detection logic here. Read that file's `## Instructions` section and execute it exactly as written, using whatever prompt or conversation context is attached to this `/wtf` invocation.