Skip to main content
Glama
nyyon-planner

nyyon-planner

by LevNyyon

nyyon-planner

Nyyon Planner — Focus Sessions, weekly objectives, honest carry-over

A local MCP server for day planning. Your AI assistant runs the planning conversation; this tool gives it memory and a method: saved day plans, weekly objectives, an honest carry-over ritual, and a rendered day card you can pin anywhere. No network, no model, nothing leaves the machine — every plan is a plain JSON file you can grep, diff, and sync however you like.

Extracted from the Daily Planner inside the Nyyon Command Center, where it plans real days.

The method (what the assistant follows)

  1. Ground first — one plan_day call returns today's plan, the week's objectives, and what's still open from recent days.

  2. The carry-over ritual — unfinished items from past days surface first, and each gets a decision: done, carry over, or drop. Nothing silently disappears.

  3. Four questions, one at a time — what do you want done today? any constraints? how many Focus Sessions fit? aligned with the week?

  4. Focus Sessions are the backbone — ~2-hour deep-work blocks, each with one concrete deliverable (what will exist when it's done). Everything else is supporting blocks and to-dos.

  5. Strategic or wing-it — a day either serves the week's 2-4 objectives or it deliberately doesn't. Both are legitimate; the plan says which.

The full brief ships in the server (plan_day returns it), so any MCP-capable assistant picks up the method with zero setup.

Related MCP server: AgentOS

The live panel (the part that closes the loop)

open_panel starts a tiny loopback-only web page — the day in the same aesthetic, but every control is real: tap a block or a to-do and it writes to the plan store; type a note ("replan the afternoon, I'm drained") and it's recorded. Each interaction becomes a signal, and the next plan_day call delivers all of them to the assistant exactly once as panel_activity — so the conversation always opens already knowing what you did with your hands. No fake buttons, no push magic: an honest pull on the next turn.

Loopback only, token-guarded URL, dies with the MCP process; the state is in the files either way.

Follow-up and analytics

Because every day is one JSON file with done-flags, review is just a read. review_period computes any range (defaults to the last 7 days):

  • completion rates — focus sessions, blocks, to-dos, and the starred few, planned vs done

  • the slippage list — items that appeared on multiple days before resolving, and the ones still stuck (the honest follow-up feed)

  • strategic vs wing-it ratio, and every touched week's objectives with their hit rate

  • a review_brief telling the assistant how to narrate the retro: lead with what shipped, read rates as patterns not grades, close by drafting next week's objectives

"Do my week in review" or "how did this month actually go" becomes one tool call plus an honest conversation.

The day card

render_plan draws any day as a clean 1080×1350 PNG — Focus Sessions accented, done items struck, the week's objectives at the foot:

Tools

tool

what it does

plan_day

Start here. The planning brief + today's plan + the week + the carry-over feed, in one call.

save_plan

Write the day: schedule blocks (focus:true for Focus Sessions, each with a deliverable) + to-dos (star:true for the critical few) + mode.

update_plan

Edit during the day — pass only the keys that change.

read_plan

One day's plan, with its still-open items computed.

list_recent_plans

Recent past days with their open items — the carry-over feed.

search_plans

Full-text search across every saved day.

read_week / set_week

The strategic layer: this week's 2-4 objectives.

review_period

Week/month analytics: completion rates, the slippage list, objectives hit rate + a retro narration brief.

render_plan

The day as a shareable PNG day card.

open_panel

The LIVE local page: real checkboxes + a note box; interactions surface as panel_activity on the next plan_day.

get_settings

Data dir, work week, theme — all env-overridable.

Install (Claude / MCP)

npm install
{
  "mcpServers": {
    "nyyon-planner": { "command": "node", "args": ["/ABSOLUTE/PATH/nyyon-planner/src/index.js"] }
  }
}

Or with the CLI: claude mcp add nyyon-planner -- node /ABSOLUTE/PATH/nyyon-planner/src/index.js

Settings

Everything is env-overridable (NYYON_PLANNER_*):

  • NYYON_PLANNER_DIR — where plans live (default ~/.nyyon-planner; plain JSON, one file per day)

  • NYYON_PLANNER_WORK_DAYS — comma list, 0=Sun..6=Sat (default 1,2,3,4,5; an Israeli work week is 0,1,2,3,4)

  • NYYON_PLANNER_WEEK_START — the week's anchor day (default: first work day). Weekend days roll forward to the coming week.

  • NYYON_PLANNER_TZ — the "today" boundary timezone (default: system)

  • NYYON_PLANNER_PAPER / INK / MUTE / LINE / ACCENT / ACCENT_WASH — day-card colors (hex)

  • NYYON_PLANNER_FONT_SANS / FONT_MONO / FONT_FILES — day-card fonts (IBM Plex bundled)

  • NYYON_PLANNER_BRAND — the footer mark on the card

  • NYYON_PLANNER_OUT — where rendered cards are written (default <data dir>/cards)

Test

npm test   # store roundtrip, week anchoring, card render — in a temp dir

Part of a family

Built like nyyon-figures: a local, offline MCP server where the calling assistant does the thinking and the tool does the persistence and the drawing. MIT.

Available Tools

12 tools
get_settingsShow settingsB

The active configuration: data directory, work week (days, anchor, timezone), and day-card theme. All overridable via NYYON_PLANNER_* env vars.

Inputs: no named parameters.

list_recent_plansRecent past plansA

The most recent PAST day plans with their open (unfinished) items — the carry-over feed. Surface these at the start of planning and ask: done, carry over, or drop?

Inputs: days.

open_panelOpen the live day panelA

Start a local web panel for the day (loopback-only, token-guarded URL): REAL checkboxes for blocks, to-dos and objectives, plus a note box. Every interaction writes to the plan store and is reported back as panel_activity on the next plan_day call. Give the user the returned URL to open (or open it for them).

Inputs: date.

plan_dayStart planning a dayA

START HERE. One call returns: the planning brief (how to run the conversation), today's date, any existing plan for the day, this week's objectives, and the open items from recent days (the carry-over feed). Follow the brief, then save_plan.

Inputs: date.

read_planRead a day planA

Read one day's saved plan (schedule + to-dos + what's still open). date default today.

Inputs: date.

read_weekRead weekly objectivesB

The strategic layer: this week's 2-4 objectives (or a given week anchor date). Strategic days align to these.

Inputs: week_start.

render_planRender a day cardA

Draw a day's plan as a clean 1080x1350 PNG (Focus Sessions accented, done items struck, the week's objectives at the foot). Returns the file path — show the image inline. Great for sharing the day or pinning it somewhere visible.

Inputs: date, out_path.

review_periodReview a period (week / month analytics)A

Follow-up analytics across saved plans: per-day rollups, completion rates (focus sessions, blocks, to-dos, starred), the SLIPPAGE list (items that appeared on multiple days before resolving — and the ones still stuck), and every touched week's objectives. Defaults to the last 7 days; pass from/to for a month or any range. The result includes a review_brief telling you how to narrate it — follow it.

Inputs: to, from.

save_planSave a day planB

Write (or replace) a day's plan. schedule = time blocks; mark each ~2h Focus Session focus:true with ONE concrete deliverable. todos with star:true for the critical few. mode "strategic" (aligned to the week — set weekly_ref to the week anchor) or "wing_it".

Inputs: schedule (required), date, mode, todos, +2 more.

search_plansSearch past plansA

Full-text search across all saved day plans (summaries, blocks, to-dos). Empty query = most recent.

Inputs: limit, query.

set_weekSet weekly objectivesB

Set the week's 2-4 strategic objectives (short outcome statements, or {text, done}). week_start default = the current week's anchor.

Inputs: objectives (required), week_start.

update_planUpdate part of a day planA

Edit a plan during the day — mark blocks/to-dos done, add items, reshuffle. Pass ONLY the keys you are changing; everything else is kept.

Inputs: date, mode, todos, summary, +2 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 12 tools

    Disambiguation5/5

    Each tool has a distinct purpose: configuration, daily planning (start/read/save/update/list/search), weekly objectives (read/set), visualization (render/interactive panel), and review (analytics). No two tools overlap in function; descriptions clearly differentiate them.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern with underscores (e.g., get_settings, plan_day, save_plan, update_plan, list_recent_plans, read_week, set_week, open_panel, review_period). No mixing of conventions.

    Tool Count5/5

    12 tools is well within the ideal range (3-15) for a planner domain. Each tool covers a necessary operation without being excessive or sparse.

    Completeness4/5

    The tool surface covers the core CRUD-like operations for plans and weeks, plus search, visualization, and analytics. Minor gap: no explicit delete tool, but overwriting (save_plan) serves as replacement. Overall, the set is nearly complete for its purpose.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      D
      maintenance
      An MCP server that gives AI assistants persistent memory across sessions. It stores project context, decisions, and progress in structured markdown files as well as a knowledge graph and sequential thinking for better memory storage.
      36
      5 npm
      1
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server providing persistent memory, goal tracking, self-reflection, and background monitoring for any MCP-compatible AI agent.
      40 PyPI
      2
      MIT
    • A
      license
      Not graded
      quality
      F
      maintenance
      A local MCP server that records completed tasks to daily JSONL files and promotes substantial work to a cumulative weekly Markdown worklog, providing persistent, searchable logs of AI-assisted productivity.
      MIT