@erclx/canon 5.11.0 → 5.13.0

package/scripts/core/clean.sh

@@ -1,36 +0,0 @@
-#!/usr/bin/env bash
-set -e
-set -o pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-source "$PROJECT_ROOT/scripts/lib/ui.sh"
-
-check_dependencies() {
-  command -v bun >/dev/null 2>&1 || log_error "bun is not installed"
-}
-
-main() {
-  check_dependencies
-
-  echo -e "${GREY}┌${NC}"
-
-  echo -e "${GREY}├${NC} ${WHITE}Cleaning artifacts${NC}"
-  rm -rf node_modules
-
-  log_rem "node_modules/"
-
-  log_step "Cleaning cache"
-  bun pm cache rm
-  log_info "Package manager cache cleared"
-
-  log_step "Rehydrating project"
-  bun install
-  log_info "Dependencies installed"
-
-  echo -e "${GREY}└${NC}\n"
-  echo -e "${GREEN}✓ Clean complete${NC}"
-}
-
-main "$@"

package/scripts/core/regen-agent-fixture.sh

@@ -1,235 +0,0 @@
-#!/usr/bin/env bash
-# Writes web/src/fixtures/agent-view.json from a real `canon sessions list
-# --json` read of this repository's own sessions.
-#
-# The page it feeds re-creates an orchestrator dispatching workers, which is the
-# one thing this toolkit does that no other surface here shows. A re-creation
-# earns nothing if the rows behind it are invented, so the session half is a
-# live listing and never a literal.
-#
-# Every role in the roster appears, not the workers alone. The controlling
-# session is pinned above the bands and planners sit in them beside workers,
-# which is what the surface being re-created does. An earlier version of this
-# script filtered the listing down to sessions holding a feature branch, and
-# that dropped the orchestrator and every planner, since a controlling session
-# and a planning session both sit on the default branch. A page about a dispatch
-# that excludes the dispatcher is the defect that filter shipped.
-#
-# Two fields cannot come from the listing and are transcribed by hand into the
-# table below. The activity text is written by Claude Code into its own status
-# line and no verb here reports it. The pull request number sits on a task file
-# with nothing joining a session record to it, which the plan behind this script
-# took as a trade rather than building the join. Both are recorded as
-# transcribed in the fixture's own header, so a reader of the committed file can
-# tell which half was measured and which was typed.
-#
-# The honesty cost this leaves open is the one assets/captures/install.html.tmpl
-# already documents for the terminal frames: a hand-edit after generation
-# defeats the discipline silently, and nothing here detects one.
-#
-# Clone-only. It reads this repository's own sessions, and a registry install
-# carries no such listing.
-set -e
-set -o pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-OUT="$PROJECT_ROOT/web/src/fixtures/agent-view.json"
-
-# Transcribed half, keyed by session name. The name is the only key that reaches
-# every row: a controlling session and a planning session both sit on the
-# default branch, so a branch cannot tell them apart or from each other. A
-# dispatched session is named `<role>-<project>-<slug>` after the work it was
-# given rather than after what it turned out to be doing, which is what makes
-# the name stable enough to key on here.
-#
-# Each row is `name|activity|pullRequest|state|age`. The state is `pinned`,
-# `working`, or `completed`, and it is where the row renders. An empty pull
-# request field is a session that had not reached its ship step when the
-# snapshot was taken.
-#
-# A pinned or working row has to appear in the live listing or this refuses, and
-# its age comes from the listing rather than the table, so the trailing field is
-# empty for those. A completed row names a session that has already exited, so
-# no listing carries it, its age is transcribed with the rest of the row, and
-# leaving that field blank would print an empty column on half the list.
-# Re-transcribe this table against a fresh listing rather than editing the
-# generated file.
-#
-# A planner belongs in this table as much as a worker does. `role-planner`
-# forbids entering a worktree, so a planner registers on the default branch at
-# launch and stays there for its whole life, which is why the branch filter this
-# script used to carry dropped every one of them permanently rather than
-# occasionally.
-ROWS=(
-  "orchestrator-canon-lead|dispatching the planners that need a plan||pinned|"
-  "worker-canon-agent-view-and-deploy|PR #1510 open (landing page)|1510|working|" # canon-allow-reference: transcribed status text
-  "planner-canon-context-wireframe-draft|drafting the context and wireframe plan||working|"
-  "planner-canon-skill-coverage-pointers|reading the skill coverage pointers||working|"
-  "planner-canon-screenshot-trap-guard|planning the screenshot trap guard||working|"
-  "planner-canon-write-route-hook-bypass|plan written; tested write probe||completed|32m"
-  "planner-canon-indexes-list-lookup|plan and task board consistent||completed|13m"
-  "worker-canon-labels-scan-body-file|address-review pass finished|1508|completed|21m"
-  "worker-canon-web-context-entry|PR #1507 addressed with commit|1507|completed|20m" # canon-allow-reference: transcribed status text
-)
-
-# The listing reports a session's repository as the main `.git` directory, which
-# is what this resolves whether the script runs from the main checkout or from a
-# linked worktree. Comparing against PROJECT_ROOT instead would match nothing
-# from a worktree, where the two differ.
-MAIN_GIT_DIR="$(cd "$PROJECT_ROOT" && git rev-parse --path-format=absolute --git-common-dir)"
-
-# `bun src/cli.ts` rather than `canon`, since a globally linked binary resolves
-# to the main checkout no matter which worktree is running, and this script is
-# run from a worktree as often as not.
-SESSIONS_JSON="$(cd "$PROJECT_ROOT" && CANON_NON_INTERACTIVE=1 bun src/cli.ts sessions list --json 2>/dev/null)"
-
-if [ -z "$SESSIONS_JSON" ]; then
-  echo "regen-agent-fixture: the session listing returned nothing, refusing to write an empty fixture" >&2
-  exit 1
-fi
-
-# The listing crosses into the eval as a file rather than an environment entry,
-# since Linux caps a single env string at 128KB and a machine running many
-# sessions can cross it, which fails the exec with E2BIG before any check can
-# report a thing.
-SESSIONS_FILE="$(mktemp)"
-trap 'rm -f "$SESSIONS_FILE"' EXIT
-printf '%s' "$SESSIONS_JSON" >"$SESSIONS_FILE"
-
-TRANSCRIBED_ROWS="$(printf '%s\n' "${ROWS[@]}")"
-READ_AT="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-
-export SESSIONS_FILE OUT PROJECT_ROOT READ_AT TRANSCRIBED_ROWS MAIN_GIT_DIR
-
-bun --eval '
-const { readFileSync } = require("node:fs")
-
-const { SESSIONS_FILE, OUT, PROJECT_ROOT, READ_AT, TRANSCRIBED_ROWS, MAIN_GIT_DIR } =
-  process.env
-
-const listing = JSON.parse(readFileSync(SESSIONS_FILE, "utf8"))
-
-const rows = TRANSCRIBED_ROWS.split("\n")
-  .map((line) => line.replace(/\s*#\s*canon-allow-reference:.*$/, "").trim())
-  .filter((line) => line !== "")
-  .map((line) => {
-    const [name, activity, pullRequest, state, age] = line.split("|")
-    return {
-      name,
-      activity,
-      pullRequest: pullRequest ? Number(pullRequest) : null,
-      state,
-      age: age || null,
-    }
-  })
-
-// Narrowed to this repository, and the reason is disclosure rather than scope.
-// `canon sessions list` is machine-wide, so an unfiltered read carries the
-// session names and worktree paths of every other project on the machine, which
-// here includes paths under a folder named `private` and several client names.
-// This fixture renders on a public page, so the filter is what keeps them off
-// it. The cost is a fidelity gap stated plainly: the real surface is
-// machine-wide and the depiction is one repository, and that is a deliberate
-// narrowing rather than an oversight.
-//
-// Keyed by name for the reason the shell comment gives: a session on the
-// default branch has no other identity, and the orchestrator and every planner
-// sit there.
-const live = new Map(
-  listing.sessions
-    .filter((session) => session.repository === MAIN_GIT_DIR)
-    .map((session) => [session.name, session]),
-)
-
-// The real surface shows an age per row, so the fixture carries one. It is
-// frozen at the read rather than live, which the rendered provenance line dates
-// so a reader is never told a stale figure is current.
-const ageLabel = (startedAt) => {
-  const minutes = Math.round(
-    (Date.parse(READ_AT) - Date.parse(startedAt)) / 60000,
-  )
-  if (!Number.isFinite(minutes) || minutes < 1) return "now"
-  if (minutes < 60) return `${minutes}m`
-  const hours = Math.round(minutes / 60)
-  return hours < 24 ? `${hours}h` : `${Math.round(hours / 24)}d`
-}
-
-// A row the page shows as running has to be running. Transcribing one that is
-// not is the failure the live half exists to prevent, so it refuses rather than
-// rendering.
-const absent = rows.filter(
-  (row) => row.state !== "completed" && !live.has(row.name),
-)
-if (absent.length > 0) {
-  console.error(
-    "regen-agent-fixture: no live session for " +
-      absent.map((row) => row.name).join(", ") +
-      ". Re-transcribe the table in this script against a fresh listing rather than editing the generated fixture.",
-  )
-  process.exit(1)
-}
-
-const sessions = rows.map((row) => {
-  const session = live.get(row.name)
-  return {
-    name: row.name,
-    branch: session ? session.branch : null,
-    state: row.state,
-    activity: row.activity,
-    pullRequest: row.pullRequest,
-    age: session ? ageLabel(session.startedAt) : row.age,
-  }
-})
-
-const ageless = sessions.filter((entry) => !entry.age)
-if (ageless.length > 0) {
-  console.error(
-    "regen-agent-fixture: no age for " +
-      ageless.map((entry) => entry.name).join(", ") +
-      ". A completed row carries its age in the table, since the session has exited and no listing reports one.",
-  )
-  process.exit(1)
-}
-
-// What the real surface prints above its own list. The remainder is every
-// session on the machine this page has no room to show, which is a real count.
-const summary = {
-  working: sessions.filter((entry) => entry.state === "working").length,
-  completed: sessions.filter((entry) => entry.state === "completed").length,
-  more: Math.max(0, listing.sessions.length - live.size),
-}
-
-const fixture = {
-  // Read by web/src/components/agent-view.astro. Every field below is either a
-  // live read or a hand transcription, and this header is what says which.
-  generatedBy: "scripts/core/regen-agent-fixture.sh",
-  readAt: READ_AT,
-  source: {
-    command: "canon sessions list --json",
-    live: [
-      "name",
-      "branch",
-      "age",
-      "that every pinned and working row is running",
-      "the remainder count",
-    ],
-    transcribed: {
-      activity:
-        "written by Claude Code into its own status line, which no verb here reports",
-      pullRequest:
-        "read off a task file by hand, since nothing joins a session record to one",
-      state:
-        "a completed session has already exited, so no listing carries the row at all",
-    },
-  },
-  summary,
-  sessions,
-}
-
-await Bun.write(OUT, JSON.stringify(fixture, null, 2) + "\n")
-console.error(
-  `regen-agent-fixture: wrote ${sessions.length} session rows to ${OUT.replace(PROJECT_ROOT + "/", "")}`,
-)
-'

package/scripts/core/regen-claude-copies.sh

@@ -1,10 +0,0 @@
-#!/usr/bin/env bash
-set -e
-set -o pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-# `.claude/rules/` is a subset rather than a mirror, so it resolves through the
-# stack machinery. The record naming the subset is `internal/governance.toml`.
-bun "$PROJECT_ROOT/src/cli.ts" gov regen --root "$PROJECT_ROOT"

package/scripts/core/regen-indexes.sh

@@ -1,10 +0,0 @@
-#!/usr/bin/env bash
-set -e
-set -o pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-source "$PROJECT_ROOT/scripts/lib/ui.sh"
-
-bun "$PROJECT_ROOT/src/cli.ts" indexes regen --root "$PROJECT_ROOT" --json >/dev/null

package/scripts/core/snapshot.sh

@@ -1,134 +0,0 @@
-#!/usr/bin/env bash
-set -e
-set -o pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-# shellcheck source=/dev/null
-source "$PROJECT_ROOT/scripts/lib/ui.sh"
-
-NESTED="${VERIFY_NESTED:-false}"
-
-OUTPUT_FILE=".canon/tmp/project/PROJECT-SNAPSHOT.md"
-
-check_dependencies() {
-  command -v find >/dev/null 2>&1 || log_error "find not installed"
-}
-
-load_gitignore_patterns() {
-  if [ ! -f ".gitignore" ]; then
-    echo ""
-    return
-  fi
-  grep -v '^\s*#' .gitignore | grep -v '^\s*$' | sed 's|/$||'
-}
-
-is_ignored() {
-  local name="$1"
-  local patterns="$2"
-
-  [ "$name" = ".git" ] && return 0
-  [ "$name" = "_" ] && return 0
-
-  while IFS= read -r pattern; do
-    [ -z "$pattern" ] && continue
-    # shellcheck disable=SC2053
-    if [[ "$name" == $pattern ]]; then
-      return 0
-    fi
-  done <<<"$patterns"
-
-  return 1
-}
-
-build_tree() {
-  local dir="${1:-.}"
-  local prefix="${2:-}"
-  local patterns="${3:-}"
-  local entries=()
-
-  while IFS= read -r entry; do
-    local name
-    name=$(basename "$entry")
-    is_ignored "$name" "$patterns" && continue
-    entries+=("$entry")
-  done < <(find "$dir" -maxdepth 1 -mindepth 1 | sort)
-
-  local count=${#entries[@]}
-  local i=0
-
-  for entry in "${entries[@]}"; do
-    i=$((i + 1))
-    local name
-    name=$(basename "$entry")
-    local connector="├──"
-    local child_prefix="${prefix}│   "
-
-    if [ "$i" -eq "$count" ]; then
-      connector="└──"
-      child_prefix="${prefix}    "
-    fi
-
-    if [ -d "$entry" ]; then
-      echo "${prefix}${connector} ${name}/"
-      build_tree "$entry" "$child_prefix" "$patterns"
-    else
-      echo "${prefix}${connector} ${name}"
-    fi
-  done
-}
-
-write_snapshot() {
-  local project_name
-  project_name=$(basename "$PWD")
-  local patterns
-  patterns=$(load_gitignore_patterns)
-
-  mkdir -p "$(dirname "$OUTPUT_FILE")"
-
-  {
-    echo "# Project Snapshot: $project_name"
-    echo ""
-    echo "## Structure"
-    echo ""
-    echo '```'
-    build_tree "." "" "$patterns"
-    echo '```'
-    echo ""
-
-    if [ -f "package.json" ]; then
-      echo "## package.json"
-      echo ""
-      echo '```json'
-      cat package.json
-      echo '```'
-      echo ""
-    fi
-  } >"$OUTPUT_FILE"
-}
-
-main() {
-  check_dependencies
-
-  if [ "$NESTED" = false ]; then open_timeline; fi
-
-  log_step "Snapshot"
-  write_snapshot
-  log_info "Written to $OUTPUT_FILE"
-
-  # The whole frame goes to stderr, since the run writes its document to a file
-  # and leaves stdout carrying nothing. Edges on stdout with the body on stderr
-  # would capture as a frame with no body inside it.
-  if [ "$NESTED" = false ]; then
-    close_timeline
-    # All six are declared to scope what `set_palette` assigns, so the four this
-    # line never spells stay out of the globals a sourcing script reads.
-    # shellcheck disable=SC2034
-    local GREEN RED YELLOW WHITE GREY NC
-    set_palette 2
-    echo -e "\n${GREEN}✓ Snapshot complete${NC}" >&2
-  fi
-}
-
-main "$@"

package/scripts/core/update.sh

@@ -1,35 +0,0 @@
-#!/usr/bin/env bash
-set -e
-set -o pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
-
-source "$PROJECT_ROOT/scripts/lib/ui.sh"
-
-check_dependencies() {
-  command -v bun >/dev/null 2>&1 || log_error "bun is not installed"
-}
-
-main() {
-  check_dependencies
-
-  echo -e "${GREY}┌${NC}"
-
-  echo -e "${GREY}├${NC} ${WHITE}Interactive dependency update${NC}"
-  echo -e "${GREY}│${NC}"
-  bun update --interactive
-
-  log_step "Verifying project health"
-  if [ -f "$PROJECT_ROOT/src/cli.ts" ]; then
-    bun "$PROJECT_ROOT/src/cli.ts" gate run --nested
-    log_info "All checks passed"
-  else
-    log_warn "Verification entry point not found, skipping."
-  fi
-
-  echo -e "${GREY}└${NC}\n"
-  echo -e "${GREEN}✓ Update complete${NC}"
-}
-
-main "$@"

package/scripts/tooling/verify.sh

@@ -1,184 +0,0 @@
-#!/usr/bin/env bash
-set -e
-set -o pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="${PROJECT_ROOT:-$(dirname "$(dirname "$SCRIPT_DIR")")}"
-
-source "$PROJECT_ROOT/scripts/lib/ui.sh"
-source "$PROJECT_ROOT/scripts/lib/tooling.sh"
-
-show_help() {
-  echo -e "${GREY}┌${NC}"
-  echo -e "${GREY}├${NC} ${WHITE}Usage:${NC} canon tooling verify <stack> [options]"
-  echo -e "${GREY}│${NC}"
-  echo -e "${GREY}│${NC}  ${WHITE}Options:${NC}"
-  echo -e "${GREY}│${NC}    --keep       ${GREY}# Keep tmp dir after run for inspection${NC}"
-  echo -e "${GREY}│${NC}    -h, --help   ${GREY}# Show this help message${NC}"
-  echo -e "${GREY}│${NC}"
-  echo -e "${GREY}│${NC}  Scaffolds <stack> into .canon/tmp/runs/verify-<stack>/, syncs the full"
-  echo -e "${GREY}│${NC}  layer chain, and runs check + test:e2e + screenshot."
-  echo -e "${GREY}└${NC}"
-  exit 0
-}
-
-read_manifest_field() {
-  local toml="$1"
-  local section="$2"
-  local field="$3"
-  awk -v s="$section" -v f="$field" '
-    $0 == "[" s "]" { in_section = 1; next }
-    in_section && /^\[/ { exit }
-    in_section && match($0, "^" f "[[:space:]]*=") {
-      val = substr($0, RLENGTH + 1)
-      sub(/^[[:space:]]+/, "", val)
-      sub(/^"/, "", val)
-      sub(/"$/, "", val)
-      print val
-      exit
-    }
-  ' "$toml"
-}
-
-run_phase() {
-  local name="$1"
-  shift
-  log_step "$name"
-  if "$@" >/tmp/verify-phase.log 2>&1; then
-    log_info "$name passed"
-    RESULTS+=("$name:pass")
-    return 0
-  fi
-  log_warn "$name failed"
-  tail -20 /tmp/verify-phase.log >&2
-  RESULTS+=("$name:fail")
-  FAILED=1
-  return 1
-}
-
-main() {
-  local stack=""
-  local keep=0
-
-  while [[ $# -gt 0 ]]; do
-    case "$1" in
-    -h | --help) show_help ;;
-    --keep)
-      keep=1
-      shift
-      ;;
-    -*)
-      log_error "Unknown option: $1"
-      ;;
-    *)
-      if [ -z "$stack" ]; then
-        stack="$1"
-        shift
-      else
-        log_error "Unexpected argument: $1"
-      fi
-      ;;
-    esac
-  done
-
-  [ -z "$stack" ] && log_error "Stack required. See --help."
-
-  export CI=1
-
-  if is_tooling_stack_excluded "$stack"; then
-    log_error "Stack '$stack' is excluded from tooling."
-  fi
-
-  local manifest="$PROJECT_ROOT/tooling/$stack/manifest.toml"
-  [ ! -f "$manifest" ] && log_error "No manifest at $manifest"
-
-  local scaffold
-  scaffold=$(read_manifest_field "$manifest" "stack" "scaffold")
-  [ -z "$scaffold" ] && log_error "Stack '$stack' has no scaffold command in manifest."
-
-  local prepare
-  prepare=$(read_manifest_field "$manifest" "verify" "prepare")
-
-  open_timeline "canon tooling verify $stack"
-  trap close_timeline EXIT
-
-  local tmp_root="$PROJECT_ROOT/.canon/tmp/runs"
-  local tmp_dir="$tmp_root/verify-$stack"
-
-  mkdir -p "$tmp_root"
-  rm -rf "$tmp_dir"
-
-  local project_name="verify-$stack"
-  local scaffold_cmd="${scaffold//\{\{name\}\}/$project_name}"
-
-  RESULTS=()
-  FAILED=0
-
-  log_step "Scaffolding $stack"
-  (cd "$tmp_root" && eval "$scaffold_cmd") >/tmp/verify-scaffold.log 2>&1 || {
-    log_warn "Scaffold failed"
-    tail -20 /tmp/verify-scaffold.log >&2
-    FAILED=1
-  }
-
-  if [ ! -d "$tmp_dir" ]; then
-    log_error "Scaffold did not produce $tmp_dir"
-  fi
-
-  (cd "$tmp_dir" && git init -q && git add . && git commit -m "chore: verify scaffold" -q --no-verify)
-
-  if [ -n "$prepare" ]; then
-    run_phase "Prepare" bash -c "cd '$tmp_dir' && $prepare"
-  fi
-
-  log_info "Sync resolves via bun $PROJECT_ROOT/src/cli.ts, not PATH canon"
-  run_phase "Sync" bash -c "cd '$tmp_dir' && CANON_NON_INTERACTIVE=1 bun '$PROJECT_ROOT/src/cli.ts' tooling sync $stack . --write"
-
-  if [ -f "$tmp_dir/package.json" ]; then
-    run_phase "lint:fix" bash -c "cd '$tmp_dir' && bun run lint:fix"
-    run_phase "check" bash -c "cd '$tmp_dir' && bun run check"
-
-    if grep -q '"test:e2e"' "$tmp_dir/package.json"; then
-      run_phase "test:e2e" bash -c "cd '$tmp_dir' && bun run test:e2e"
-    fi
-
-    if grep -q '"screenshot"' "$tmp_dir/package.json"; then
-      if run_phase "screenshot" bash -c "cd '$tmp_dir' && timeout 60 bun run screenshot"; then
-        local shots
-        shots=$(find "$tmp_dir/screenshots" -type f -name '*.png' 2>/dev/null | wc -l)
-        if [ "$shots" -eq 0 ]; then
-          log_warn "screenshot produced no png files"
-          RESULTS+=("screenshot-artifacts:fail")
-          FAILED=1
-        else
-          RESULTS+=("screenshot-artifacts:pass")
-        fi
-      fi
-    fi
-  fi
-
-  log_step "Results"
-  for r in "${RESULTS[@]}"; do
-    local name="${r%:*}"
-    local status="${r##*:}"
-    if [ "$status" = "pass" ]; then
-      log_info "$name"
-    else
-      log_warn "$name"
-    fi
-  done
-
-  if [ "$keep" -eq 0 ] && [ "$FAILED" -eq 0 ]; then
-    rm -rf "$tmp_dir"
-  else
-    log_info "Kept $tmp_dir"
-  fi
-
-  if [ "$FAILED" -ne 0 ]; then
-    exit 1
-  fi
-}
-
-if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
-  main "$@"
-fi