@jenga-ai/agent 1.0.1 → 1.1.1

package/mcp/training_runner/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "training-runner-mcp-server",
+  "version": "1.0.0",
+  "description": "MCP server that validates and runs ML training jobs via bash start.sh",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.10.1",
+    "js-yaml": "^4.1.0",
+    "zod": "^3.23.8"
+  }
+}

package/package.json

@@ -1,17 +1,13 @@
 {
   "name": "@jenga-ai/agent",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "JengaAgent — agentic project management CLI",
   "type": "module",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/samwelmunga/jenga-npm.git"
-  },
   "publishConfig": {
     "access": "public"
   },
   "bin": {
-    "jenga": "bin/jenga.js"
+    "jenga": "./bin/jenga.js"
   },
   "scripts": {
     "postinstall": "node scripts/postinstall.js",
@@ -30,22 +26,24 @@
     "templates/",
     "bin/",
     "lib/",
-    "mcp/execute-ticket/",
-    "mcp/help/",
-    "mcp/router/index.js",
-    "mcp/router/matcher.js",
-    "mcp/router/embedder.js",
-    "mcp/router/skill-index.js",
-    "mcp/router/package.json",
-    "mcp/router/package-lock.json",
-    "mcp/router/README.md",
+    "mcp/",
     "README.md",
     "LICENSE"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/samwelmunga/jenga-npm"
+  },
   "keywords": [],
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@xenova/transformers": "^2.17.2"
+    "@huggingface/transformers": "^4.2.0"
+  },
+  "overrides": {
+    "sharp": "^0.34.5"
+  },
+  "comments": {
+    "audit": "sharp <0.35.0 and adm-zip <0.6.0 are transitive deps of @huggingface/transformers with no upstream fix available. Not exploitable in this context: only text feature-extraction pipeline is used — no image processing or ZIP handling at application boundary. Review when @huggingface/transformers ships a patched release."
   }
 }

package/scripts/check-permission-level.sh

@@ -0,0 +1,107 @@
+#!/usr/bin/env bash
+#
+# check-permission-level.sh — read-only gate for a skill's declared minimum
+# permission level (the `minimum_permission_level` SKILL.md frontmatter field,
+# see docs/skill-authoring.md).
+#
+# ============================================================================
+# CHECK vs ENFORCE — READ THIS BEFORE WIRING THIS SCRIPT INTO A SKILL
+# ============================================================================
+# This script is READ-ONLY. It CHECKS the current session's permission level
+# against a required minimum and SIGNALS the result. It does NOT:
+#   - prompt the user for confirmation
+#   - elevate the session level
+#   - write to .jenga-permission-level.json, .claude/settings.json, or
+#     .agents/settings.json under any code path
+#
+# The CALLING SKILL's own instructions are responsible for:
+#   1. Detecting the `NEEDS_CONFIRMATION` signal (non-zero exit) below.
+#   2. Explicitly asking the user to confirm elevation (no silent
+#      auto-elevation, ever).
+#   3. On confirmation, invoking `jenga-permission-level-switch.sh <minimum-level>`
+#      (a sibling script, scripts/jenga-permission-level-switch.sh — task E33_S02_T02) to
+#      actually perform the elevation.
+#   4. Immediately after the skill's own work completes, resetting the
+#      session back to Guarded (2) — typically via `jenga-permission-level-switch.sh 2` as
+#      the skill's last step. This reset is NOT automatic and is NOT this
+#      script's job.
+#
+# Usage:
+#   scripts/check-permission-level.sh <minimum-level>
+#
+#   <minimum-level>  Integer 1-5 — the value a calling skill read from its
+#                     own `minimum_permission_level` frontmatter field.
+#
+# Exit codes:
+#   0  Current session level already meets <minimum-level>. No output.
+#   1  Current session level is below <minimum-level>. Prints:
+#        NEEDS_CONFIRMATION: elevate from <current> to <minimum-level>
+#   2  Bad usage / invalid argument. Prints an error to stderr.
+#
+# Current level source:
+#   .jenga-permission-level.json at the repo root, field `session_level`
+#   (the format `jenga-permission-level-switch.sh`, E33_S02_T02, writes: {"session_level": <n>}).
+#   Missing file, unreadable file, malformed JSON, or a missing/non-integer
+#   `session_level` field are all treated as level 2 (Guarded), the
+#   permanent default — this script never fails merely because the level
+#   file is absent or malformed.
+# ============================================================================
+
+set -euo pipefail
+
+usage() {
+  echo "Usage: $(basename "$0") <minimum-level>" >&2
+  echo "  <minimum-level> must be an integer 1-5 (the skill's minimum_permission_level)." >&2
+}
+
+if [ "$#" -ne 1 ]; then
+  usage
+  exit 2
+fi
+
+MIN_LEVEL="$1"
+
+case "$MIN_LEVEL" in
+  1|2|3|4|5) ;;
+  *)
+    echo "Error: <minimum-level> must be an integer 1-5, got: '$MIN_LEVEL'" >&2
+    usage
+    exit 2
+    ;;
+esac
+
+LEVEL_FILE=".jenga-permission-level.json"
+CURRENT_LEVEL=2
+
+if [ -f "$LEVEL_FILE" ]; then
+  if command -v python3 >/dev/null 2>&1; then
+    PARSED=$(python3 -c "
+import json, sys
+try:
+    with open('$LEVEL_FILE') as f:
+        data = json.load(f)
+    level = data.get('session_level')
+    if isinstance(level, bool) or not isinstance(level, int) or not (1 <= level <= 5):
+        raise ValueError('invalid session_level')
+    print(level)
+except Exception:
+    print(2)
+" 2>/dev/null || echo 2)
+    CURRENT_LEVEL="$PARSED"
+  else
+    # No python3 available — fall back to a permissive grep-based extraction.
+    # Any failure to confidently parse an integer 1-5 falls back to level 2.
+    GREPPED=$(grep -o '"session_level"[[:space:]]*:[[:space:]]*[0-9]' "$LEVEL_FILE" 2>/dev/null | grep -o '[0-9]$' | head -n1 || true)
+    case "$GREPPED" in
+      1|2|3|4|5) CURRENT_LEVEL="$GREPPED" ;;
+      *) CURRENT_LEVEL=2 ;;
+    esac
+  fi
+fi
+
+if [ "$CURRENT_LEVEL" -ge "$MIN_LEVEL" ]; then
+  exit 0
+fi
+
+echo "NEEDS_CONFIRMATION: elevate from $CURRENT_LEVEL to $MIN_LEVEL"
+exit 1

package/scripts/check-publicignore-match.sh

@@ -0,0 +1,122 @@
+#!/usr/bin/env bash
+# ---------------------------------------------------------------------------
+# scripts/check-publicignore-match.sh
+#
+# Classify one or more repo-relative paths as PUBLIC (would ship to the
+# public mirror repo) or BLOCKED (excluded by .publicignore), using the
+# exact same rsync --exclude-from=.publicignore matching semantics as
+# skills/mirror-public/scripts/mirror.sh's --dry-run "ship list" computation
+# (see the SHIP_LIST_FILE block in that script). A file classified as
+# "would be blocked" by `/mirror-public --dry-run` is guaranteed to be
+# classified as BLOCKED here too, and vice versa for PUBLIC.
+#
+# This does NOT touch the network, clone the public repo, or require
+# /mirror-public to be configured (skills/mirror-public/assets/config.json
+# is never read) — it only needs a .publicignore file at the repo root.
+# Rsync's include/exclude filter evaluation does not depend on destination
+# state (destination state only affects delete/itemize-flag details for
+# files already present there), so probing against an empty scratch temp
+# directory yields an identical "would ship" set to probing against
+# mirror.sh's real public-clone destination.
+#
+# Callers (e.g. /doc-sync step 4, and the E36 changelog generator's
+# .publicignore-awareness) are expected to skip invoking this script
+# entirely when .publicignore does not exist at the repo root — that is
+# the established no-op-when-absent precedent, and it stays owned by each
+# caller rather than being silently absorbed here.
+#
+# Usage:
+#   check-publicignore-match.sh <path> [<path> ...]
+#
+# Paths are interpreted relative to the repo root (same convention as
+# `git ls-files`). Output: one "STATUS<TAB>path" line per input path, in
+# input order. STATUS is PUBLIC or BLOCKED.
+#
+# Note: a path that does not exist on disk is classified BLOCKED (it will
+# not appear in rsync's transfer list regardless of .publicignore). Callers
+# such as /doc-sync only ever pass paths already confirmed to exist as
+# real new-in-source candidates, so this does not arise in practice — but
+# it is not the same guarantee as ".publicignore explicitly matched it".
+#
+# Exit codes:
+#   0  classification completed (regardless of individual PUBLIC/BLOCKED results)
+#   1  usage error
+#   2  repo root not found, .publicignore missing, or rsync unavailable
+# ---------------------------------------------------------------------------
+
+set -euo pipefail
+IFS=$'\n\t'
+
+die() {
+  printf 'check-publicignore-match.sh: error: %s\n' "$*" >&2
+  exit 2
+}
+
+if [ "$#" -eq 0 ]; then
+  printf 'usage: check-publicignore-match.sh <path> [<path> ...]\n' >&2
+  exit 1
+fi
+
+SCRIPT_PATH="${BASH_SOURCE[0]}"
+while [ -h "$SCRIPT_PATH" ]; do
+  LINK_TARGET="$(readlink "$SCRIPT_PATH")"
+  case "$LINK_TARGET" in
+    /*) SCRIPT_PATH="$LINK_TARGET" ;;
+    *)  SCRIPT_PATH="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)/$LINK_TARGET" ;;
+  esac
+done
+SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
+
+REPO_ROOT="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel 2>/dev/null || true)"
+[ -n "$REPO_ROOT" ] || die "could not locate repo root (git rev-parse failed from $SCRIPT_DIR)"
+
+PUBLICIGNORE="$REPO_ROOT/.publicignore"
+[ -f "$PUBLICIGNORE" ] || die "no .publicignore at $PUBLICIGNORE (caller should skip invoking this script when absent — that is the no-op case, not an error the caller should surface)"
+
+command -v rsync >/dev/null 2>&1 || die "rsync not installed"
+
+TMP_DEST="$(mktemp -d)"
+SHIP_LIST_FILE="$(mktemp)"
+cleanup() {
+  rm -rf "$TMP_DEST"
+  rm -f "$SHIP_LIST_FILE"
+}
+trap cleanup EXIT
+
+# Same rsync flags + itemize/awk filter as mirror.sh's --dry-run ship-list
+# computation (kept in lockstep with that block intentionally), targeted at
+# an empty scratch dir instead of a real public clone.
+rsync -a --delete \
+  --exclude-from="$PUBLICIGNORE" \
+  --exclude=".git" \
+  --dry-run --itemize-changes --out-format='%i %n' \
+  "$REPO_ROOT/" \
+  "$TMP_DEST/" \
+  | awk '{
+      flag = $1;
+      first  = substr(flag, 1, 1);
+      second = substr(flag, 2, 1);
+      # Skip directories — public tree recreates them implicitly.
+      if (second == "d") next;
+      # Keep only entries that transfer or create a file/symlink/hardlink.
+      keep = 0;
+      if (first == ">" || first == "<") keep = 1;   # file transfer
+      else if (first == "c" && second == "L") keep = 1;  # create symlink
+      else if (first == "h") keep = 1;              # hard link
+      if (!keep) next;
+      $1 = "";
+      sub(/^ /, "");
+      sub(/\/$/, "");
+      if (length($0) > 0) print $0;
+    }' \
+  | LC_ALL=C sort -u > "$SHIP_LIST_FILE"
+
+for candidate in "$@"; do
+  # Normalize a single leading "./" if present, so callers can pass either form.
+  norm="${candidate#./}"
+  if LC_ALL=C grep -Fxq "$norm" "$SHIP_LIST_FILE"; then
+    printf 'PUBLIC\t%s\n' "$candidate"
+  else
+    printf 'BLOCKED\t%s\n' "$candidate"
+  fi
+done

package/scripts/check-worktree-liveness.sh

@@ -0,0 +1,193 @@
+#!/usr/bin/env bash
+# scripts/check-worktree-liveness.sh — detect OS processes still rooted
+# inside a given worktree path.
+#
+# Usage:
+#   scripts/check-worktree-liveness.sh <worktree-path>
+#
+# Why this exists: `ListAgents` reports agent lifecycle, not detached OS
+# processes. A live incident (2026-08-25, see E37's Purpose) showed a
+# completed agent leaving shell polling loops running with their cwd inside
+# a worktree; `ListAgents` showed the agent itself as "completed" and gave
+# no signal that those loops were still alive, so the worktree was removed
+# out from under them. This script answers a narrower, deterministic
+# question instead: "does any OS process currently have its *current
+# working directory* rooted inside this path (the path itself, or any
+# subdirectory of it)?" It is intended to be run as a precondition before
+# `git worktree remove` (wired in the sibling task E37_S03_T02, not here —
+# this task only produces the standalone check).
+#
+# Detection mechanism (primary): `lsof +D <path> -F pcfn`
+#   `+D <path>` recursively restricts lsof's report to files open within
+#   that directory subtree (this alone gives us "inside the given path,
+#   including subdirectories" — verified locally against a nested-subdir
+#   case). `-F pcfn` is lsof's machine-parsable output mode, emitting one
+#   attribute per line: `p<pid>`, `c<command>`, `f<fd-or-descriptor-type>`,
+#   `n<file name>`, grouped per matching open-file record. Records are then
+#   filtered down to those whose `f` field is literally `cwd` — this is what
+#   distinguishes "this process's current working directory is here" from
+#   "this process merely has some unrelated file open under here" (e.g. a
+#   log file), which `+D` alone does not distinguish.
+#
+#   `-F pcfn` (not lsof's default human-readable columnar output) is used
+#   deliberately: column widths/ordering in the default output are not
+#   guaranteed stable across lsof versions/platforms, whereas the `-F` field
+#   protocol is. Verified directly against this repo's own Darwin runtime
+#   (lsof 4.91) — both an exact-path cwd match and a subdirectory cwd match
+#   are correctly reported, and process cwd is resolved through symlinks
+#   (macOS reports `/tmp/x` as `/private/tmp/x`), which is why the input
+#   path is canonicalized below before comparison.
+#
+# Detection mechanism (fallback, when `lsof` is not on PATH): enumerate
+# `/proc/[0-9]*` (Linux only — macOS has no `/proc`) and `readlink` each
+# `/proc/<pid>/cwd`, comparing against the canonicalized target path. macOS
+# ships `lsof` by default, so this branch is not expected to run on this
+# repo's actual runtime, but keeps the script functional on minimal Linux
+# containers that may lack `lsof`. If neither mechanism is available, the
+# script cannot determine liveness at all and fails closed (non-zero exit,
+# clear stderr message) rather than silently reporting "clear" when it does
+# not actually know.
+#
+# Command-line resolution for reported matches uses `ps -o command= -p
+# <pid>` — confirmed to behave identically on macOS's BSD `ps` and Linux's
+# GNU `ps`, unlike some other `ps` flags/keywords (e.g. `-e` listing
+# semantics differ between BSD and GNU `ps`, which is why the fallback path
+# above enumerates PIDs via `/proc` rather than `ps -e`).
+#
+# Caller-cwd self-detection hardening: if the *caller* invokes this script
+# from a shell whose own cwd is already inside the target path (e.g. `cd
+# <worktree> && check-worktree-liveness.sh <worktree>` — a very plausible
+# state right before a worktree is removed), every subprocess the script
+# forks (the `lsof` child, and the process-substitution subshell wrapping
+# it below, or the `readlink` calls in the /proc fallback) would otherwise
+# *inherit* that cwd, since bash processes inherit cwd from their parent by
+# default. That produced a real, reproduced false positive: the script's
+# own subprocess chain got reported as a "live process rooted in" the very
+# path being checked, even with zero genuinely orphaned processes running.
+# See project/rapports/problems/E37_S03_T01-self-detection-false-positive-remarks.md
+# for the original reproduction and the two fix options it proposed.
+#
+# Fix: immediately after resolving $ABS_PATH (and before spawning anything),
+# the script `cd`s itself to `/` — a path guaranteed to be outside every
+# possible target. This moves the *script's own process* outside the target,
+# so every descendant it forks from this point on inherits a cwd of `/`
+# instead of the caller's original cwd, regardless of where the caller
+# happened to be standing when it invoked this script. This is preferred
+# over tracking and excluding individual subprocess PIDs (the script's own
+# PID `$$` was already excluded as a courtesy, see below) because `cd /`
+# removes the precondition for the whole bug class structurally, rather
+# than requiring every current and future subprocess this script might ever
+# spawn to be enumerated and excluded by PID after the fact.
+#
+# The script also excludes its own PID ($$) from reported matches as a
+# second, defense-in-depth courtesy (now largely redundant given the `cd /`
+# fix above, but harmless to keep).
+#
+# Exit codes:
+#   0   clear — no live process found, no output
+#   1   one or more live processes found — PID(s) and command(s) printed
+#   2   invalid usage (wrong argument count / empty argument)
+#   3   <worktree-path> does not resolve to an existing directory
+#   4   unable to determine liveness on this platform (neither `lsof` nor
+#       /proc available) — fail closed, this is NOT the same as "clear"
+
+set -u
+
+SCRIPT_NAME="check-worktree-liveness.sh"
+
+usage() {
+  echo "Usage: $SCRIPT_NAME <worktree-path>" >&2
+  exit 2
+}
+
+[ "$#" -eq 1 ] || usage
+RAW_PATH="$1"
+[ -n "$RAW_PATH" ] || usage
+
+if [ ! -d "$RAW_PATH" ]; then
+  echo "$SCRIPT_NAME: '$RAW_PATH' is not a directory" >&2
+  exit 3
+fi
+
+# Canonicalize to an absolute, symlink-resolved path so comparisons against
+# process cwd values (which the OS reports fully resolved — e.g. macOS
+# reports /tmp as /private/tmp) match correctly regardless of how the
+# caller spelled the input path.
+ABS_PATH="$(cd "$RAW_PATH" 2>/dev/null && pwd -P)"
+if [ -z "$ABS_PATH" ]; then
+  echo "$SCRIPT_NAME: unable to resolve '$RAW_PATH' to an absolute path" >&2
+  exit 3
+fi
+
+# Move this process (and therefore every subprocess it forks from here on)
+# outside of every possible target path, so the scan below can never
+# self-detect regardless of the caller's cwd at invocation time. See the
+# "Caller-cwd self-detection hardening" comment in the header above. `/` is
+# always present and readable on every platform this script targets; if for
+# some reason it could not be `cd`'d into, fall through rather than abort —
+# worst case the pre-existing $$ exclusion below is the only mitigation,
+# same as before this fix.
+cd / 2>/dev/null || true
+
+SELF_PID="$$"
+FOUND_ANY=0
+REPORTED_PIDS=""
+
+already_reported() {
+  case " $REPORTED_PIDS " in
+    *" $1 "*) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+report_match() {
+  pid="$1"
+  already_reported "$pid" && return 0
+  REPORTED_PIDS="$REPORTED_PIDS $pid"
+  cmd="$(ps -o command= -p "$pid" 2>/dev/null)"
+  [ -n "$cmd" ] || cmd="(command unavailable — process may have exited)"
+  echo "$SCRIPT_NAME: live process rooted in '$ABS_PATH' — PID $pid: $cmd"
+  FOUND_ANY=1
+}
+
+if command -v lsof >/dev/null 2>&1; then
+  current_pid=""
+  current_fd=""
+  while IFS= read -r line; do
+    case "$line" in
+      p*)
+        current_pid="${line#p}"
+        current_fd=""
+        ;;
+      f*)
+        current_fd="${line#f}"
+        ;;
+      n*)
+        if [ "$current_fd" = "cwd" ] && [ -n "$current_pid" ] && [ "$current_pid" != "$SELF_PID" ]; then
+          report_match "$current_pid"
+        fi
+        ;;
+    esac
+  done < <(lsof +D "$ABS_PATH" -F pcfn 2>/dev/null)
+else
+  if [ -d /proc ]; then
+    for pid_dir in /proc/[0-9]*; do
+      [ -e "$pid_dir" ] || continue
+      pid="${pid_dir#/proc/}"
+      [ "$pid" != "$SELF_PID" ] || continue
+      cwd_link="$(readlink "$pid_dir/cwd" 2>/dev/null)" || continue
+      [ -n "$cwd_link" ] || continue
+      case "$cwd_link" in
+        "$ABS_PATH"|"$ABS_PATH"/*)
+          report_match "$pid"
+          ;;
+      esac
+    done
+  else
+    echo "$SCRIPT_NAME: neither 'lsof' nor /proc is available on this system — cannot determine worktree liveness for '$ABS_PATH'" >&2
+    exit 4
+  fi
+fi
+
+[ "$FOUND_ANY" -eq 1 ] && exit 1
+exit 0

package/scripts/generate-rapport-manifest.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+# scripts/generate-rapport-manifest.sh
+#
+# Regenerates the rapport manifest used by hooks/on_session_end.sh to detect
+# *new* problem rapports (project/rapports/problems/*.md, excluding resolved
+# *.IGNORE.md files). This script is the single source of truth for "what
+# does the manifest look like right now" — it is used both to produce the
+# committed seed manifest and, at runtime, by the hook itself whenever it
+# rewrites the manifest after finding new rapports.
+#
+# Entries are stored as paths relative to the repo root (e.g.
+# "project/rapports/problems/foo.md"), NOT absolute paths. The manifest is
+# a committed artifact shared across every clone/worktree, each of which
+# has a different absolute checkout location — absolute paths would make
+# the seed match nobody's filesystem but the one it was generated on.
+#
+# Safe to re-run at any time: it is a pure snapshot of the current directory
+# contents, never a diff, so running it twice in a row produces identical
+# output.
+#
+# Usage: scripts/generate-rapport-manifest.sh [output_file]
+#   output_file defaults to project/data/rapport_manifest.json
+
+set -euo pipefail
+
+# shellcheck source=lib/resolve-project-dir.sh
+source "$(git rev-parse --show-toplevel)/lib/resolve-project-dir.sh"
+
+PROJECT_DIR="$JENGA_PROJECT_DIR"
+RAPPORT_DIR="$PROJECT_DIR/project/rapports/problems"
+OUTPUT="${1:-$PROJECT_DIR/project/data/rapport_manifest.json}"
+
+mkdir -p "$(dirname "$OUTPUT")"
+
+if [ -d "$RAPPORT_DIR" ]; then
+  find "$RAPPORT_DIR" -name "*.md" ! -name "*.IGNORE.md" 2>/dev/null \
+    | sed "s|^$PROJECT_DIR/||" \
+    | sort | jq -R . | jq -s . > "$OUTPUT"
+else
+  echo "[]" > "$OUTPUT"
+fi
+
+echo "Wrote $(jq 'length' "$OUTPUT") rapport filename(s) to $OUTPUT"

package/scripts/idea_manager.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+# scripts/idea_manager.sh — canonical owner of all project/ideas.md operations.
+# Run from the repository root.
+
+IDEA_FILE="project/ideas.md"
+TEMPLATE="skills/idea/assets/idea_template.md"
+
+usage() {
+  cat >&2 <<EOF
+Usage: $0 <subcommand> [args]
+
+Subcommands:
+  add "<entry>"    Append entry to project/ideas.md (auto-creates from template if missing)
+  list             Print all non-comment, non-blank entries (silent if file missing/empty)
+EOF
+  exit 1
+}
+
+# Filters out blank lines, lines starting with #, and HTML comments
+real_entries() {
+  grep -v '^\s*$' "$1" 2>/dev/null \
+    | grep -v '^\s*#' \
+    | grep -v '^\s*<!--'
+}
+
+case "${1:-}" in
+  add)
+    [ -z "${2:-}" ] && { echo "Error: add requires an entry argument" >&2; exit 1; }
+    if [ ! -f "$IDEA_FILE" ]; then
+      if [ ! -f "$TEMPLATE" ]; then
+        echo "Error: template not found at $TEMPLATE" >&2; exit 1
+      fi
+      cp "$TEMPLATE" "$IDEA_FILE"
+    fi
+    printf '%s\n' "$2" >> "$IDEA_FILE"
+    ;;
+
+  list)
+    [ ! -f "$IDEA_FILE" ] && exit 0
+    real_entries "$IDEA_FILE"
+    exit 0
+    ;;
+
+  *)
+    usage
+    ;;
+esac