@theglitchking/persistent-planning 3.0.1 → 3.4.0

package/hooks/session-start.js

@@ -1,13 +1,196 @@
 #!/usr/bin/env node
 // persistent-planning SessionStart hook.
-// Delegates entirely to @theglitchking/claude-plugin-runtime — this plugin
-// has no mcp.json wiring or project-side reconcile, so only the update
-// check runs.
+//
+// Three jobs:
+//   1. The update check, delegated entirely to @theglitchking/claude-plugin-runtime.
+//   2. A completion nudge: if any plan under .planning/ has every box checked
+//      but is still sitting in the active tree, say so, so the agent archives it
+//      instead of rediscovering a finished plan next session.
+//   3. A drift warning: if .claude/skills/persistent-planning is a real directory
+//      rather than a symlink into this package, it is a frozen v1 copy and every
+//      /start-planning is running stale code. See issue #10.
+//   4. Under updatePolicy: auto, actually repair that drift. This hook is the only
+//      code that runs every session in a marketplace install -- that shape has no
+//      node_modules in the plugin cache and never runs npm postinstall -- so it is
+//      the only delivery path a fix can reach existing broken installs through.
 
 import { runSessionStart } from "@theglitchking/claude-plugin-runtime";
+import { spawnSync } from "node:child_process";
+import { dirname, join, resolve } from "node:path";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { driftedSkills, readSkillVersion } from "../scripts/lib/skill-link.js";
 
-await runSessionStart({
-  packageName: "@theglitchking/persistent-planning",
-  pluginName: "persistent-planning",
-  configFile: "persistent-planning.json",
-});
+const projectRoot = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+function planNudge() {
+  try {
+    if (!existsSync(join(projectRoot, ".planning"))) return "";
+    const script = join(packageRoot, "scripts", "plan-status.sh");
+    if (!existsSync(script)) return "";
+    const r = spawnSync("bash", [script, "--nudge"], {
+      cwd: projectRoot,
+      env: { ...process.env, CLAUDE_PROJECT_DIR: projectRoot },
+      encoding: "utf8",
+      timeout: 5000,
+    });
+    return (r.stdout || "").trim();
+  } catch {
+    return "";
+  }
+}
+
+function updatePolicy() {
+  try {
+    const raw = readFileSync(join(projectRoot, ".claude", "persistent-planning.json"), "utf8");
+    return JSON.parse(raw)?.updatePolicy || "nudge";
+  } catch {
+    return "nudge";
+  }
+}
+
+function packageVersion() {
+  try {
+    return JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8")).version || null;
+  } catch {
+    return null;
+  }
+}
+
+const CONFIG = join(projectRoot, ".claude", "persistent-planning.json");
+
+function readConfig() {
+  try { return JSON.parse(readFileSync(CONFIG, "utf8")) || {}; } catch { return {}; }
+}
+
+/**
+ * Repair a drifted skill dir, at most once per plugin version.
+ *
+ * Runs the package's own linker, which reclaims the stale dir, symlinks, and stamps
+ * the version marker. Spawned rather than imported so a failure is contained in a
+ * child process and cannot take the hook down with it.
+ *
+ * Returns a one-line summary to fold into the session notice, or "".
+ */
+function autoRepair() {
+  try {
+    const policy = updatePolicy();
+    if (policy !== "auto") return "";                       // nudge/off: warn only
+
+    // Fast path first — two lstats, and the overwhelmingly common answer is "nothing
+    // to do". Never pay for the migration on a healthy install.
+    if (!driftedSkills(projectRoot, packageRoot, "skills").length) return "";
+
+    const version = packageVersion();
+    const cfg = readConfig();
+    if (version && cfg.repairedSkillsForVersion === version) return "";  // once per version
+
+    const linker = join(packageRoot, "scripts", "link-skills.js");
+    if (!existsSync(linker)) return "";
+
+    const r = spawnSync(process.execPath, [linker], {
+      cwd: projectRoot,
+      env: { ...process.env, INIT_CWD: projectRoot },
+      encoding: "utf8",
+      timeout: 10000,
+    });
+
+    // Stamp regardless of outcome: a repair that cannot succeed must not retry every
+    // session. A later release moves the version and gets one fresh attempt.
+    try {
+      writeFileSync(CONFIG, JSON.stringify({ ...cfg, repairedSkillsForVersion: version }, null, 2) + "\n", "utf8");
+    } catch { /* config unwritable — the drift warning still fires every session */ }
+
+    const remaining = driftedSkills(projectRoot, packageRoot, "skills");
+    if (remaining.length || r.status !== 0) return "";      // let driftNudge() report it
+    return "[persistent-planning] repaired a stale skill directory (originals kept as .bak-*).";
+  } catch {
+    return "";
+  }
+}
+
+function driftNudge() {
+  try {
+    // A user who turned updates off did not ask to be nagged about them either.
+    if (updatePolicy() === "off") return "";
+    const drifted = driftedSkills(projectRoot, packageRoot, "skills");
+    if (!drifted.length) return "";
+
+    let pkgVersion = "unknown";
+    try {
+      pkgVersion = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8")).version;
+    } catch { /* keep "unknown" */ }
+
+    const lines = drifted.map((d) => {
+      const found = readSkillVersion(projectRoot, d.name) || "unversioned (pre-3.1.0 copy)";
+      const why = d.state === "real-dir"
+        ? "is a real directory, not a symlink into the installed package"
+        : `is a symlink to ${d.target}, which is not this package`;
+      return `  - ${d.dest}\n    ${why}\n    running: ${found} | installed: ${pkgVersion}`;
+    });
+
+    return [
+      "[persistent-planning] STALE SKILL DIRECTORY — commands are running frozen code.",
+      ...lines,
+      "  Plans generated from a pre-3.1.0 copy silently omit the mandatory validate and",
+      "  documentation phases and the whole 'On Completion' archive block.",
+      "  Fix:  npx persistent-planning relink",
+    ].join("\n");
+  } catch {
+    // Fail open. A broken drift check must never cost anyone their session start.
+    return "";
+  }
+}
+
+// Repair before reporting, so a successful auto-repair does not also warn.
+const repaired = autoRepair();
+const notice = [planNudge(), repaired, driftNudge()].filter(Boolean).join("\n\n");
+
+if (!notice) {
+  await runSessionStart({
+    packageName: "@theglitchking/persistent-planning",
+    pluginName: "persistent-planning",
+    configFile: "persistent-planning.json",
+  });
+} else {
+  // ponytail: the runtime owns the one SessionStart JSON response and exposes no
+  // hook for appending to it, and a second response line on stdout is invalid.
+  // So intercept its single write and merge the nudge into that same payload.
+  // Fails open — anything unexpected is written through untouched.
+  const realWrite = process.stdout.write.bind(process.stdout);
+  let merged = false;
+  process.stdout.write = (chunk, ...rest) => {
+    if (!merged) {
+      try {
+        const payload = JSON.parse(String(chunk));
+        const out = payload?.hookSpecificOutput;
+        if (out && out.hookEventName === "SessionStart") {
+          out.additionalContext = out.additionalContext
+            ? `${out.additionalContext}\n${notice}`
+            : notice;
+          merged = true;
+          return realWrite(JSON.stringify(payload) + "\n", ...rest);
+        }
+      } catch {
+        // Not the response payload — fall through and write it as-is.
+      }
+    }
+    return realWrite(chunk, ...rest);
+  };
+
+  await runSessionStart({
+    packageName: "@theglitchking/persistent-planning",
+    pluginName: "persistent-planning",
+    configFile: "persistent-planning.json",
+  });
+
+  // The runtime can return without emitting (e.g. it chdir-failed). Say our piece.
+  if (!merged) {
+    realWrite(
+      JSON.stringify({
+        hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: notice },
+      }) + "\n"
+    );
+  }
+}

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@theglitchking/persistent-planning",
-  "version": "3.0.1",
+  "version": "3.4.0",
   "description": "Persistent markdown-based planning with task directories, progress tracking, and context engineering for multi-step Claude Code workflows",
   "type": "module",
   "bin": {
     "persistent-planning": "bin/persistent-planning.js"
   },
   "scripts": {
-    "postinstall": "node scripts/link-skills.js"
+    "postinstall": "node scripts/link-skills.js",
+    "test": "bash tests/run.sh"
   },
   "files": [
     "bin/",
@@ -16,7 +17,8 @@
     "scripts/",
     "templates/",
     "skills/",
-    "docs/",
+    ".documentation/",
+    "!.documentation/reports",
     ".claude-plugin/",
     "README.md",
     "LICENSE",
@@ -57,6 +59,7 @@
     "commander": "^14.0.0"
   },
   "devDependencies": {
+    "@theglitchking/hit-em-with-the-docs": "^2.9.0",
     "@theglitchking/semantic-pages": "^0.10.0"
   }
 }

package/scripts/archive-plan.sh

@@ -0,0 +1,143 @@
+#!/bin/bash
+###############################################################################
+# archive-plan.sh - Retire a completed plan into .planning/.archive/
+#
+# Usage:
+#   bash scripts/archive-plan.sh <plan-slug>
+#   bash scripts/archive-plan.sh --all-complete
+#   bash scripts/archive-plan.sh <plan-slug> --force     # archive an unfinished plan
+#   bash scripts/archive-plan.sh <plan-slug> --dry-run
+#
+# What it does:
+#   1. Refuses unless the plan is complete (every checkbox checked, or the
+#      top-level artifact declares `status: done`) -- override with --force.
+#   2. Ensures .planning/.archive/ exists and is gitignored.
+#   3. Moves .planning/<slug>/ to .planning/.archive/<slug>/ (git mv when the
+#      plan is tracked, so history follows it).
+#   4. Stamps the plan's top-level artifact with status: archived + archived_on.
+#
+# Nothing is ever deleted. Restore by moving the directory back out.
+###############################################################################
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/lib/planning.sh"
+
+SLUG=""
+ALL_COMPLETE=0
+FORCE=0
+DRY_RUN=0
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --all-complete) ALL_COMPLETE=1; shift ;;
+    --force)        FORCE=1; shift ;;
+    --dry-run)      DRY_RUN=1; shift ;;
+    -h|--help)      sed -n '2,20p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; exit 0 ;;
+    -*)             planning_err "Unknown option: $1"; exit 1 ;;
+    *)              [[ -z "$SLUG" ]] && SLUG="$1"; shift ;;
+  esac
+done
+
+if [[ -z "$SLUG" && $ALL_COMPLETE -eq 0 ]]; then
+  planning_err "A plan slug is required (or --all-complete)."
+  echo "Usage: bash scripts/archive-plan.sh <plan-slug> [--force] [--dry-run]"
+  exit 1
+fi
+
+ROOT=$(planning_root)
+PLANNING="$(planning_dir)"
+ARCHIVE="${PLANNING}/.archive"
+TODAY=$(planning_today)
+
+# .planning/.archive/ must be gitignored: completed plans are local history, not
+# something every clone should carry. Shared with the init scripts so there is one
+# rule, not two — it also warns when a blanket .planning/ entry is hiding everything.
+ensure_gitignored() {
+  planning_ensure_archive_gitignored "${ROOT}" 1
+}
+
+plan_root_artifact() {
+  for f in "$1/phase.md" "$1/task_plan.md" "$1/task.md"; do
+    [[ -f "$f" ]] && { echo "$f"; return; }
+  done
+}
+
+# Stamp the plan's top-level artifact so an archived plan reads as archived even
+# when someone opens the file directly, with no directory context.
+stamp_archived() {
+  local file="$1"
+  [[ -f "$file" ]] || return 0
+  if head -1 "$file" | grep -q '^---$'; then
+    # Frontmatter: flip status and add archived_on before the closing delimiter.
+    awk -v today="$TODAY" '
+      NR == 1 { print; next }
+      !done_fm && /^status:[[:space:]]*/ { print "status: archived"; seen_status = 1; next }
+      !done_fm && /^---$/ {
+        if (!seen_status) print "status: archived"
+        print "archived_on: \"" today "\""
+        print; done_fm = 1; next
+      }
+      { print }
+    ' "$file" > "${file}.tmp" && mv "${file}.tmp" "$file"
+  else
+    printf '\n---\n\n**Archived %s** — retired by `scripts/archive-plan.sh`.\n' "$TODAY" >> "$file"
+  fi
+}
+
+archive_one() {
+  local slug="$1"
+  local src="${PLANNING}/${slug}"
+  local dest="${ARCHIVE}/${slug}"
+
+  if [[ ! -d "$src" ]]; then
+    planning_err "No such plan: .planning/${slug}/"
+    return 1
+  fi
+  if [[ -e "$dest" ]]; then
+    planning_err "Already archived: .planning/.archive/${slug}/ exists. Move or rename it first."
+    return 1
+  fi
+
+  if [[ $FORCE -eq 0 ]]; then
+    local complete
+    complete=$(bash "${SCRIPT_DIR}/plan-status.sh" --complete | grep -Fx "$slug" || true)
+    if [[ -z "$complete" ]]; then
+      planning_err "Plan '${slug}' is not complete — refusing to archive."
+      echo "  Check what is outstanding with: bash scripts/plan-status.sh"
+      echo "  Archive anyway with:            bash scripts/archive-plan.sh ${slug} --force"
+      return 1
+    fi
+  fi
+
+  if [[ $DRY_RUN -eq 1 ]]; then
+    planning_log "[dry-run] would archive .planning/${slug}/ -> .planning/.archive/${slug}/"
+    return 0
+  fi
+
+  ensure_gitignored
+  mkdir -p "$ARCHIVE"
+
+  if git -C "$ROOT" rev-parse --git-dir >/dev/null 2>&1 \
+     && [[ -n "$(git -C "$ROOT" ls-files ".planning/${slug}" 2>/dev/null)" ]]; then
+    git -C "$ROOT" mv ".planning/${slug}" ".planning/.archive/${slug}"
+  else
+    mv "$src" "$dest"
+  fi
+
+  stamp_archived "$(plan_root_artifact "$dest")"
+  planning_ok "Archived .planning/${slug}/ -> .planning/.archive/${slug}/"
+}
+
+RC=0
+if [[ $ALL_COMPLETE -eq 1 ]]; then
+  mapfile -t SLUGS < <(bash "${SCRIPT_DIR}/plan-status.sh" --complete)
+  if [[ ${#SLUGS[@]} -eq 0 || -z "${SLUGS[0]}" ]]; then
+    planning_log "No complete plans to archive."
+    exit 0
+  fi
+  for s in "${SLUGS[@]}"; do archive_one "$s" || RC=1; done
+else
+  archive_one "$SLUG" || RC=1
+fi
+exit $RC

package/scripts/init-atom.sh

@@ -130,6 +130,13 @@ planning_render_and_log \
   "ATOM_DATE_PLACEHOLDER=${TODAY}" \
   "ATOM_SEQUENCE_PLACEHOLDER=${NEXT_SEQUENCE}"
 
+# Write the atom into its task's list. Same gap as init-task.sh had with
+# phase.md: the atom file was created and never referenced anywhere (#12).
+planning_insert_list_item \
+  "${TASK_DIR}/task.md" \
+  "## Atoms" \
+  "- [ ] **${ATOM_NAME}** (\`atoms/${ATOM_SLUG}.md\`, sequence: ${NEXT_SEQUENCE})"
+
 echo ""
 planning_ok "Atom '${ATOM_NAME}' ready"
 echo ""

package/scripts/init-phase.sh

@@ -125,12 +125,64 @@ planning_render_and_log \
   "NOTES_SCOPE_PLACEHOLDER=${PHASE_SLUG}" \
   "NOTES_DATE_PLACEHOLDER=${TODAY}"
 
-# Add .planning/ to .gitignore if missing (preserve existing behavior)
-GITIGNORE="${ROOT}/.gitignore"
-if [[ -f "$GITIGNORE" ]] && ! grep -q "^\.planning/" "$GITIGNORE"; then
-  echo ".planning/" >> "$GITIGNORE"
-  planning_ok "Added .planning/ to .gitignore"
-fi
+# Scaffold the two mandatory closing tasks as real task directories.
+#
+# They used to exist only as two checkbox lines in phase.md, so the most important
+# tasks in every plan were the only ones with no artifact for a subagent to read and
+# nowhere to record decisions — and every real plan hand-built them (issue #12).
+scaffold_closer() { # <slug> <title> <atom>...
+  local slug="$1" title="$2"; shift 2
+  local dir="${PHASE_DIR}/${slug}"
+  mkdir -p "${dir}/atoms"
+
+  planning_render_and_log \
+    "${TEMPLATE_DIR}/task.md" \
+    "${dir}/task.md" \
+    "closer task at ${dir}/task.md" \
+    "TASK_TITLE_PLACEHOLDER=${title}" \
+    "TASK_SLUG_PLACEHOLDER=${slug}" \
+    "PHASE_SLUG_PLACEHOLDER=${PHASE_SLUG}" \
+    "TASK_DATE_PLACEHOLDER=${TODAY}"
+
+  planning_render_and_log \
+    "${TEMPLATE_DIR}/notes.md" \
+    "${dir}/notes.md" \
+    "closer notes at ${dir}/notes.md" \
+    "NOTES_TITLE_PLACEHOLDER=${title} — Notes" \
+    "NOTES_SCOPE_PLACEHOLDER=${PHASE_SLUG}/${slug}" \
+    "NOTES_DATE_PLACEHOLDER=${TODAY}"
+
+  # mandatory: true is what plan-status.sh gates on. parallelizable stays false —
+  # a closer gates on everything before it.
+  [[ -f "${dir}/task.md" ]] && sed -i 's/^mandatory: false$/mandatory: true/' "${dir}/task.md"
+
+  local atom
+  for atom in "$@"; do
+    planning_insert_list_item "${dir}/task.md" "## Atoms" "- [ ] ${atom}"
+  done
+}
+
+scaffold_closer \
+  "validate-success-through-comprehensive-testing" \
+  "Validate success through comprehensive testing" \
+  "Prove every claim this phase makes with a test that fails if it breaks" \
+  "Test the invariant after mutation, not the shape of a freshly rendered template" \
+  "Cover the failure mode that prompted the work, not just the happy path" \
+  "Run the full suite green before closing this task"
+
+scaffold_closer \
+  "documentation-pass-create-update-deprecate-docs" \
+  "Documentation pass — create/update/deprecate docs" \
+  "Create docs for what was built: what it is, where it lives, how it works" \
+  "Add a troubleshooting entry for the symptom someone will actually search for" \
+  "Update every existing doc this phase made wrong — a stale doc is worse than a missing one" \
+  "Retire superseded docs with \`npx hewtd archive <file>\` — never by deleting" \
+  "If hit-em-with-the-docs is installed you MUST use it: \`npx hewtd integrate <file> -a\` to create, \`npx hewtd maintain --quick\` to regenerate indexes" \
+  "Run \`npx hewtd audit\` and resolve every error" \
+  "Never hand-edit INDEX.md or REGISTRY.md — they are generated"
+
+# Only completed plans are local history — see planning_ensure_archive_gitignored.
+planning_ensure_archive_gitignored "${ROOT}"
 
 echo ""
 planning_ok "Phase '${PHASE_NAME}' ready at .planning/${PHASE_SLUG}/"

package/scripts/init-planning.sh

@@ -105,6 +105,19 @@ if [ ! -f "$TASK_PLAN_FILE" ]; then
 - [ ] Phase 2: Research/gather information
 - [ ] Phase 3: Execute/build
 - [ ] Phase 4: Review and deliver
+- [ ] Phase 5: Validate success through comprehensive testing (MANDATORY)
+- [ ] Phase 6: Documentation pass -- create/update/deprecate as many docs as needed to capture what was done, where it lives, how to troubleshoot it, etc. etc.. etc.. (MANDATORY)
+
+> Phases 5 and 6 are mandatory and MUST stay the last two phases of this plan.
+> Insert new work above them; never after. Renumber them if you add phases.
+>
+> - **Validate success**: prove the work with tests that fail if the change breaks.
+> - **Documentation pass**: create/update/deprecate every doc this change touches --
+>   what it is, where it lives, how to fix it, how to operate it, why it matters.
+>   If hit-em-with-the-docs is installed, you MUST use it for this pass --
+>   `npx hewtd integrate <file> -a` to create, `npx hewtd archive <file>` to retire,
+>   `npx hewtd maintain --quick` to regenerate indexes. Never hand-edit INDEX.md or
+>   REGISTRY.md; they are generated.
 
 ## Key Questions
 1. [Question to answer]
@@ -126,9 +139,22 @@ if [ ! -f "$TASK_PLAN_FILE" ]; then
 - Update status after each phase
 - Mark completed phases with [x]
 - Save research to notes.md instead of stuffing context
+
+## On Completion
+This plan is complete when every checkbox above is checked. That IS the
+completion signal -- there is no separate status to remember to flip.
+
+When complete, archive it instead of deleting it:
+
+    /plan-status                  # confirm this plan reads COMPLETE
+    /archive-plan TASK_SLUG_PLACEHOLDER    # -> .planning/.archive/TASK_SLUG_PLACEHOLDER/
+
+Archiving moves this directory to the gitignored .planning/.archive/ and stamps
+it archived. Nothing is destroyed.
 EOF
 
     sed -i "s/TASK_NAME_PLACEHOLDER/${TASK_NAME}/g" "$TASK_PLAN_FILE"
+    sed -i "s/TASK_SLUG_PLACEHOLDER/${TASK_SLUG}/g" "$TASK_PLAN_FILE"
     echo -e "${GREEN}+${NC} Created task_plan.md"
 else
     echo -e "${YELLOW}*${NC} task_plan.md already exists (not overwritten)"
@@ -182,12 +208,21 @@ else
 fi
 
 # Step 5: Update .gitignore
+#
+# Only completed plans are local history. Active plans are what a teammate or a
+# subagent reads, so they stay shareable (issue #15). This script is deliberately
+# self-contained -- no lib/planning.sh -- so the rule is duplicated here rather than
+# sourced; scripts/lib/planning.sh has the lg-mode copy.
 if [ -f "${PROJECT_ROOT}/.gitignore" ]; then
-    if ! grep -q "^\.planning/" "${PROJECT_ROOT}/.gitignore"; then
-        echo ".planning/" >> "${PROJECT_ROOT}/.gitignore"
-        echo -e "${GREEN}+${NC} Added .planning/ to .gitignore"
+    if grep -qE "^\.planning/?$" "${PROJECT_ROOT}/.gitignore"; then
+        echo -e "${YELLOW}*${NC} .gitignore ignores all of .planning/ -- plans will not be shared."
+        echo -e "  Active plans are what teammates and subagents read. To share them,"
+        echo -e "  replace the '.planning/' line with '.planning/.archive/'."
+    elif grep -qE "^\.planning/\.archive/?$" "${PROJECT_ROOT}/.gitignore"; then
+        echo -e "${YELLOW}*${NC} .planning/.archive/ already in .gitignore"
     else
-        echo -e "${YELLOW}*${NC} .planning/ already in .gitignore"
+        printf '\n# Completed plans retired by scripts/archive-plan.sh (local history)\n.planning/.archive/\n' >> "${PROJECT_ROOT}/.gitignore"
+        echo -e "${GREEN}+${NC} Added .planning/.archive/ to .gitignore (active plans stay shareable)"
     fi
 else
     echo -e "${YELLOW}*${NC} No .gitignore found (not added)"

package/scripts/init-task.sh

@@ -109,6 +109,13 @@ planning_render_and_log \
   "NOTES_SCOPE_PLACEHOLDER=${PARENT_PHASE}/${TASK_SLUG}" \
   "NOTES_DATE_PLACEHOLDER=${TODAY}"
 
+# Write the task into its phase's list, above the mandatory closers. Before this,
+# init-task.sh never touched phase.md and every list was maintained by hand (#12).
+planning_insert_list_item \
+  "${PHASE_DIR}/phase.md" \
+  "## Tasks" \
+  "- [ ] **${TASK_NAME}** (\`${TASK_SLUG}\`)"
+
 echo ""
 planning_ok "Task '${TASK_NAME}' ready at .planning/${PARENT_PHASE}/${TASK_SLUG}/"
 echo ""