deepvista-cli 0.2.0__tar.gz → 0.3.0__tar.gz

deepvista_cli-0.3.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.3.0"
+}

{deepvista_cli-0.2.0 → deepvista_cli-0.3.0}/CHANGELOG.md

@@ -37,6 +37,18 @@ users what's new between the version they have installed and the latest release.
   adopts a pre-existing server-side row instead of failing when the local
   file is missing.
 
+## [0.3.0](https://github.com/DeepVista-AI/deepvista-cli/compare/v0.2.0...v0.3.0) (2026-05-31)
+
+
+### Features
+
+* **DV-871:** move daily-planning to server; add schedule command ([#151](https://github.com/DeepVista-AI/deepvista-cli/issues/151)) ([7c317e7](https://github.com/DeepVista-AI/deepvista-cli/commit/7c317e7d6f71763f6622354b8581ead8b10ef8ea))
+
+
+### Bug Fixes
+
+* **types:** mark output_error as NoReturn to fix Pyright errors in schedule.py ([#153](https://github.com/DeepVista-AI/deepvista-cli/issues/153)) ([7ac8b12](https://github.com/DeepVista-AI/deepvista-cli/commit/7ac8b12f1b10a94cd6dbe8533b122a2cf8489228))
+
 ## [0.2.0](https://github.com/DeepVista-AI/deepvista-cli/compare/v0.1.18...v0.2.0) (2026-05-28)
 
 

{deepvista_cli-0.2.0 → deepvista_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepvista-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: CLI for DeepVista — chat, notes, skills, and memory from your terminal.
 Project-URL: Homepage, https://deepvista.ai
 Project-URL: Repository, https://github.com/DeepVista-AI/deepvista-cli

deepvista_cli-0.3.0/deepvista_cli/commands/schedule.py

@@ -0,0 +1,169 @@
+"""deepvista schedule — opt-in recurring runs of the daily-planning skill.
+
+Daily planning generation lives on the DeepVista server (the
+``deepvista-daily-planning`` skill). This command lets the user *explicitly*
+activate a recurring server job that generates today's planning note on a cron
+schedule — nothing runs automatically until the user opts in here, which keeps
+token spend under their control.
+
+Under the hood each "activation" is a row in the server's ``scheduled_jobs``
+table whose ``prompt`` asks the agent to run the daily-planning skill. The
+heartbeat dispatcher drains due rows and runs the agent.
+"""
+
+from __future__ import annotations
+
+import click
+
+from deepvista_cli.client.http import DeepVistaClient
+from deepvista_cli.output.formatter import format_output, output_error
+
+# The server-side workflow skill that generates the planning note.
+DAILY_PLANNING_SKILL = "deepvista-daily-planning"
+# Stable title used to find this job again (activate is idempotent on it).
+JOB_TITLE = "Daily Planning"
+# Cron is evaluated in UTC server-side (no per-user timezone yet — see DV-879).
+DEFAULT_DAILY_CRON = "0 8 * * *"
+DEFAULT_WEEKLY_CRON = "0 8 * * 1"
+
+# Columns shown in `--format table`.
+_JOB_COLUMNS = ["id", "title", "cron_schedule", "enabled", "next_run_at", "last_run_at"]
+
+
+def _client(ctx: click.Context) -> DeepVistaClient:
+    return ctx.obj._client
+
+
+def _find_daily_planning_job(ctx: click.Context) -> dict | None:
+    """Return the existing daily-planning job for this user, or None.
+
+    Matches on the stable ``JOB_TITLE`` so repeated activations re-use the same
+    row instead of stacking duplicates.
+    """
+    data = _client(ctx).get("/scheduled-jobs")
+    for job in data.get("jobs", []):
+        if job.get("title") == JOB_TITLE:
+            return job
+    return None
+
+
+@click.group("schedule")
+def schedule_group() -> None:
+    """Manage the recurring daily-planning job (opt-in)."""
+
+
+@schedule_group.command("activate")
+@click.option("--cron", "cron_schedule", default=None, help="5-field cron in UTC (default: daily 08:00 UTC).")
+@click.option("--weekly", is_flag=True, default=False, help="Run weekly (Mon 08:00 UTC) instead of daily.")
+@click.pass_context
+def schedule_activate(ctx: click.Context, cron_schedule: str | None, weekly: bool) -> None:
+    """Activate the recurring daily-planning job.
+
+    Idempotent: if a daily-planning job already exists it is re-enabled rather
+    than duplicated. To change the cron of an existing job, deactivate + delete
+    it first, then activate again with a new --cron.
+    """
+    cadence = "weekly" if weekly else "daily"
+    if cron_schedule is None:
+        cron_schedule = DEFAULT_WEEKLY_CRON if weekly else DEFAULT_DAILY_CRON
+
+    existing = _find_daily_planning_job(ctx)
+    if existing is not None:
+        if existing.get("enabled"):
+            format_output(
+                {"status": "already_active", "job": existing},
+                ctx.obj.output_format,
+                title="Daily planning already active",
+            )
+            return
+        resp = _client(ctx).patch(f"/scheduled-jobs/{existing['id']}", {"enabled": True})
+        format_output(
+            {"status": "reactivated", "job": resp.get("job", resp)},
+            ctx.obj.output_format,
+            title="Daily planning reactivated",
+        )
+        return
+
+    prompt = (
+        f"Run the {DAILY_PLANNING_SKILL} skill to generate today's daily "
+        f"planning note (cadence: {cadence}). List the workflow Skills that "
+        f"should run today as context-card chips in the note's Planning section."
+    )
+    resp = _client(ctx).post(
+        "/scheduled-jobs",
+        {
+            "prompt": prompt,
+            "cron_schedule": cron_schedule,
+            "title": JOB_TITLE,
+            "enabled": True,
+        },
+    )
+    if not resp.get("success"):
+        output_error(1, "Failed to activate daily planning", resp.get("error", ""))
+    format_output(
+        {"status": "activated", "cadence": cadence, "job": resp.get("job", resp)},
+        ctx.obj.output_format,
+        title="Daily planning activated",
+    )
+
+
+@schedule_group.command("deactivate")
+@click.pass_context
+def schedule_deactivate(ctx: click.Context) -> None:
+    """Disable the daily-planning job (keeps the row so it can be re-activated)."""
+    existing = _find_daily_planning_job(ctx)
+    if existing is None:
+        output_error(1, "No daily-planning job found", "Run: deepvista schedule activate")
+    if not existing.get("enabled"):
+        format_output(
+            {"status": "already_inactive", "job": existing},
+            ctx.obj.output_format,
+            title="Daily planning already inactive",
+        )
+        return
+    resp = _client(ctx).patch(f"/scheduled-jobs/{existing['id']}", {"enabled": False})
+    format_output(
+        {"status": "deactivated", "job": resp.get("job", resp)},
+        ctx.obj.output_format,
+        title="Daily planning deactivated",
+    )
+
+
+@schedule_group.command("list")
+@click.pass_context
+def schedule_list(ctx: click.Context) -> None:
+    """List the caller's scheduled jobs (read-only)."""
+    data = _client(ctx).get("/scheduled-jobs")
+    jobs = data.get("jobs", [])
+    format_output(
+        {"jobs": jobs, "count": len(jobs)},
+        ctx.obj.output_format,
+        columns=_JOB_COLUMNS,
+        title="Scheduled Jobs",
+    )
+
+
+@schedule_group.command("delete")
+@click.argument("job_id", required=False)
+@click.pass_context
+def schedule_delete(ctx: click.Context, job_id: str | None) -> None:
+    """Delete a scheduled job permanently.
+
+    With no JOB_ID, deletes the daily-planning job. Use this (then ``activate``)
+    to change a job's cron, which PATCH can't edit. Pass ``--dry-run`` on the
+    root command to preview without deleting.
+    """
+    if job_id is None:
+        existing = _find_daily_planning_job(ctx)
+        if existing is None:
+            output_error(1, "No daily-planning job found", "Pass a JOB_ID, or run: deepvista schedule list")
+        job_id = existing["id"]
+
+    resp = _client(ctx).delete(f"/scheduled-jobs/{job_id}")
+    if not resp.get("success"):
+        output_error(1, "Failed to delete scheduled job", resp.get("error", ""))
+    format_output(
+        {"status": "deleted", "job_id": job_id},
+        ctx.obj.output_format,
+        title="Scheduled job deleted",
+    )

{deepvista_cli-0.2.0 → deepvista_cli-0.3.0}/deepvista_cli/main.py

@@ -31,6 +31,7 @@ from deepvista_cli.commands.config import config_group
 from deepvista_cli.commands.lint import lint_command
 from deepvista_cli.commands.memory import vistabase_group
 from deepvista_cli.commands.notes import notes_group
+from deepvista_cli.commands.schedule import schedule_group
 from deepvista_cli.commands.session import session_group
 from deepvista_cli.commands.skill import skill_group
 from deepvista_cli.commands.upgrade import upgrade_command
@@ -87,6 +88,8 @@ for _name, _cmd in card_group.commands.items():
 cli.add_command(vistabase_group, name="memory")
 # Agent orchestration
 cli.add_command(agents_group)
+# Opt-in recurring daily-planning job
+cli.add_command(schedule_group)
 # Agent session transcripts (DV-742) — `init` / `tick` / `finalize`
 cli.add_command(session_group)
 # Supporting commands

{deepvista_cli-0.2.0 → deepvista_cli-0.3.0}/deepvista_cli/output/formatter.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 import json
 import sys
-from typing import Any
+from typing import Any, NoReturn
 
 import click
 
@@ -170,7 +170,7 @@ def output_table(data: Any, columns: list[str] | None = None, title: str | None
         output_json(data)
 
 
-def output_error(code: int, message: str, detail: str = "") -> None:
+def output_error(code: int, message: str, detail: str = "") -> NoReturn:
     """Write structured error to stderr and exit."""
     err = {"error": {"code": code, "message": message}}
     if detail:

{deepvista_cli-0.2.0 → deepvista_cli-0.3.0}/plugins/claude-code/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "deepvista",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Remote-managed skill catalog from DeepVista. Auto-syncs thin stubs into the plugin's skills dir on SessionStart; full bodies are lazy-loaded at invocation time.",
   "author": {
     "name": "DeepVista AI",

deepvista_cli-0.3.0/plugins/claude-code/commands/deepvista.md

@@ -0,0 +1,115 @@
+---
+description: DeepVista controls — `run` executes today's Daily Planning note (each workflow via a subagent); no args shows help
+argument-hint: "[run]"
+---
+
+DeepVista control surface. Behaviour depends on `$ARGUMENTS`:
+
+- **No argument** (or any value other than `run`) → print the help block below.
+- **`run`** → execute today's *Daily Planning* note: launch a subagent per
+  workflow Skill listed in its `## Planning` section, then append a
+  consolidated `## Summary` back onto the note.
+
+**Generation moved server-side.** Today's planning note is created by the
+DeepVista server agent via the `deepvista-daily-planning` skill — either on a
+schedule you opt into (`deepvista schedule activate`) or on demand. This command
+only *processes* (runs) a note that already exists. Planning notes are regular
+DeepVista notes (`type=note`) tagged ``daily-planning`` + ``date:YYYYMMDD``.
+
+---
+
+## If `$ARGUMENTS` is empty or not `run`
+
+Print this verbatim, then stop:
+
+> **DeepVista — Claude Code commands**
+>
+> - `/deepvista run` — execute today's *Daily Planning* note. Reads the note's
+>   `## Planning` workflow chips and runs each workflow Skill with a subagent,
+>   then appends the results under a `## Summary — <timestamp>` block.
+> - `/refresh-skills` — resync the DeepVista skill catalog and agent
+>   definitions immediately (bypasses the 60-minute throttle).
+>
+> **Generating today's plan**
+>
+> - Planning is generated by the DeepVista server, not here. Activate a daily
+>   run with `deepvista schedule activate` (or `--weekly`), or ask DeepVista to
+>   run the `deepvista-daily-planning` skill on demand.
+> - `deepvista schedule list` / `deepvista schedule deactivate` manage it.
+>
+> **Tips**
+>
+> - Need help with the CLI itself? `deepvista --help` or `deepvista <group> --help`.
+
+## If `$ARGUMENTS` is `run`
+
+Execute today's planning note.
+
+### Step 1 — Find today's planning note
+
+```bash
+TODAY=$(date +%Y%m%d)
+deepvista --format json card +search "Daily Planning $TODAY" --limit 5
+```
+
+Pick the card whose `tags` include both ``daily-planning`` and ``date:$TODAY``,
+then fetch its full body:
+
+```bash
+deepvista --format json notes get <note-id>
+```
+
+If **no note exists for today**, stop and tell the user to generate one first —
+generation is server-side now: `deepvista schedule activate` for a recurring
+run, or ask DeepVista to run the `deepvista-daily-planning` skill on demand. Do
+**not** try to generate the plan from this command.
+
+### Step 2 — Run each workflow with a subagent
+
+Read the note's `## Planning` section. It lists the workflow Skills to run today
+as context-card chips (`<contextCardBlock cardType="skill" id="...">`). You don't
+need to hand-parse anything mechanically — read the note and, for each workflow
+chip in order, launch a subagent to load and run that workflow Skill end-to-end
+(`deepvista skill run <skill-id>` drives it host-side). Give each subagent the
+planning note's intent so it has context.
+
+For each workflow, capture:
+
+- **Time** — how long the run took (or start/finish).
+- **Output** — the deliverable / where it landed (note id, card, artifact).
+
+If a chip's skill id can't be resolved or a run fails, record the error for that
+workflow and continue with the rest — don't abort the whole run.
+
+### Step 3 — Append a consolidated summary to the note
+
+Build one markdown block:
+
+```
+## Summary — <YYYY-MM-DD HH:MM>
+
+### <Workflow 1 title>
+- Time: <duration>
+- Output: <result / link>
+
+### <Workflow 2 title>
+- Time: <duration>
+- Output: <result / link>
+```
+
+Read the current body, append the block, write it back:
+
+```bash
+deepvista --format json notes get <note-id>
+# Capture description, append the block, then:
+deepvista notes update <note-id> --content-file -
+```
+
+### Step 4 — Report
+
+Tell the user, in two lines:
+
+- Which workflows ran (and any that were skipped or failed).
+- The planning note URL (`https://app.deepvista.ai/notes/<id>`).
+
+If any step fails, stop and surface the error — do not silently fall through.

{deepvista_cli-0.2.0 → deepvista_cli-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepvista-cli"
-version = "0.2.0"
+version = "0.3.0"
 description = "CLI for DeepVista — chat, notes, skills, and memory from your terminal."
 readme = "README.md"
 license = { text = "Apache-2.0" }

{deepvista_cli-0.2.0 → deepvista_cli-0.3.0}/uv.lock

@@ -56,7 +56,7 @@ wheels = [
 
 [[package]]
 name = "deepvista-cli"
-version = "0.2.0"
+version = "0.3.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },

deepvista_cli-0.2.0/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.2.0"
-}

deepvista_cli-0.2.0/plugins/claude-code/commands/deepvista.md

@@ -1,129 +0,0 @@
----
-description: DeepVista controls — `run` generates + dispatches today's planning note via the daily-planning skill; no args shows help
-argument-hint: "[run]"
----
-
-DeepVista control surface. Behaviour depends on `$ARGUMENTS`:
-
-- **No argument** (or any value other than `run`) → print the help block below.
-- **`run`** → generate today's *Daily Planning* note via the `daily-planning`
-  skill (if one doesn't already exist), dispatch each `## <role>` section to
-  its matching `@<role>` subagent, and append a consolidated summary back
-  onto the note.
-
-Planning notes are stored as regular DeepVista notes (`type=note`) tagged
-``daily-planning`` + ``date:YYYYMMDD``. No dedicated `deepvista planning`
-CLI command exists — read/write everything via `deepvista notes` and
-`deepvista card +search`.
-
----
-
-## If `$ARGUMENTS` is empty or not `run`
-
-Print this verbatim, then stop:
-
-> **DeepVista — Claude Code commands**
->
-> - `/deepvista run` — generate today's *Daily Planning* note (LLM-reasoned,
->   driven by the `daily-planning` skill: yesterday's progress + last 7 days
->   of cards → per-role tasks), then dispatch each `## <role>` section to
->   the matching `@<role>` subagent. Subagent results are appended back to
->   the planning note under a `## Summary — <timestamp>` block.
-> - `/refresh-skills` — resync the DeepVista skill catalog and agent
->   definitions immediately (bypasses the 60-minute throttle).
->
-> **Tips**
->
-> - Want to draft a plan without dispatching? Just say *"draft today's
->   planning note"* and the `daily-planning` skill kicks in.
-> - Personalise a subagent's voice by setting `config.system_prompt` on its
->   managed agent (free text, e.g. *"You are the marketing specialist;
->   follow persona context card persona-mkt-001."*) and re-running
->   `/refresh-skills`. The agent loads the persona card at runtime.
-> - Need help with the CLI itself? `deepvista --help` or `deepvista <group> --help`.
-
-## If `$ARGUMENTS` is `run`
-
-Execute the daily-planning dispatch workflow.
-
-### Step 1 — Find today's planning note (or generate one)
-
-```bash
-TODAY=$(date +%Y%m%d)
-deepvista --format json card +search "Daily Planning $TODAY" --limit 5
-```
-
-Walk the result and pick the card with both ``daily-planning`` and
-``date:$TODAY`` in `tags`. Two cases:
-
-- **No match** → today's note doesn't exist. **Load the `daily-planning`
-  skill and follow it end-to-end** to produce today's plan. The skill ends
-  by saving the note via `deepvista notes create`. Re-run the search above
-  to pick up the new note id.
-
-- **Match found** → fetch its full body:
-  ```bash
-  deepvista --format json notes get <note-id>
-  ```
-
-Parse `description` and split on `## ` headings. Treat headings that match
-``Workflow today`` or ``Summary`` (case-insensitive) as reserved; everything
-else is a role section keyed by its heading text (lowercased).
-
-### Step 2 — Dispatch each role section to its subagent
-
-For each `(role, section_markdown)` in the role sections, invoke the
-matching subagent inline. Skip any role with no on-disk `dv-<role>.md`
-definition — the user hasn't registered a managed agent for it yet.
-Example body:
-
-```
-@<role>
-
-You are dispatched from today's Daily Planning note (id: <note_id>).
-
-Your section reads:
-
-<section_markdown>
-
-Complete it end-to-end. Return your deliverable in the standard subagent
-output format (Frame → Deliverable → Sources → Captured).
-```
-
-Collect each subagent's full reply.
-
-### Step 3 — Append a consolidated summary to the note
-
-Build a single markdown block:
-
-```
-## Summary — <YYYY-MM-DD HH:MM>
-
-### @marketing
-<that subagent's reply>
-
-### @engineering
-<that subagent's reply>
-
-…
-```
-
-Read the current body, append the block, write it back:
-
-```bash
-deepvista --format json notes get <note-id>
-# Capture description from JSON, append the block, then:
-deepvista notes update <note-id> --content-file -
-# (pass `description + appended_block` on stdin)
-```
-
-### Step 4 — Report
-
-Tell the user, in two lines:
-
-- Whether the plan was generated this run (and via which skill), or pulled
-  from an existing note.
-- Roles dispatched (and any skipped because no matching subagent existed),
-  plus the planning note URL (`https://app.deepvista.ai/notes/<id>`).
-
-If any step fails, stop and surface the error — do not silently fall through.

deepvista_cli-0.2.0/plugins/claude-code/skills/daily-planning/SKILL.md

@@ -1,161 +0,0 @@
----
-name: daily-planning
-description: |
-  Generate today's *Daily Planning* note by reading yesterday's plan (and its
-  appended progress summary) along with recent context cards from the last 7
-  days — then reason about what carries over, what's new, and what each
-  registered `@<role>` managed-agent subagent should own today. Save the
-  result as a regular DeepVista note tagged ``daily-planning`` +
-  ``date:YYYYMMDD``. Use when the user runs `/deepvista run` and today's
-  planning note doesn't yet exist, or when the user asks to "draft today's
-  plan", "make today's standup", or "regenerate my daily planning note".
----
-
-# Daily planning — generate today's plan from yesterday's context
-
-This skill produces today's *Daily Planning* note as an LLM-reasoned plan,
-not a static template. Planning notes are plain `deepvista notes` cards
-(type=note) tagged ``daily-planning`` + ``date:YYYYMMDD`` — there is no
-dedicated `deepvista planning` subcommand. The flow:
-
-1. Read **yesterday's** planning note + appended summary (if it exists).
-2. Read the **last 7 days** of context cards (notes, todos, sessions).
-3. List the **`@<role>` subagents** registered for this user.
-4. Reason about carry-over, new tasks, and blockers.
-5. Save the result as a note via `deepvista notes create`.
-
-The CLI does the data lookups; this skill is the reasoning runbook.
-
-## Step 1 — Read yesterday's plan
-
-Search for yesterday's planning note by tag (titles can be edited; tags
-shouldn't). Hybrid search filtered to `type=note` is the most robust:
-
-```bash
-YESTERDAY=$(date -v-1d +%Y%m%d 2>/dev/null || date -d 'yesterday' +%Y%m%d)
-TODAY=$(date +%Y%m%d)
-
-deepvista --format json card +search "Daily Planning $YESTERDAY" --limit 5
-# If a match is found, fetch its full body:
-# deepvista --format json notes get <id>
-```
-
-Parse `description` (yesterday's full markdown — plan + any
-`## Summary — <timestamp>` blocks that `/deepvista run` appended after
-subagents finished). If nothing matches, treat yesterday as a clean slate.
-
-## Step 2 — Read the last 7 days of context cards
-
-Each call is bounded (`--limit 20`). Skip silently on failure.
-
-```bash
-deepvista --format json notes list --limit 20
-deepvista --format json card list --type todo  --limit 20
-deepvista --format json card list --type session --limit 10
-deepvista --format json card +search "progress OR blocker OR shipped OR next" --limit 10
-```
-
-For each result, keep only items updated in the last 7 days. Extract:
-
-- title
-- last-updated date
-- a one-sentence read of what it implies for today
-
-## Step 3 — List the registered `@<role>` subagents
-
-```bash
-ls "${CLAUDE_PLUGIN_ROOT:-$HOME/.claude/plugins/deepvista}/agents/" 2>/dev/null \
-  | grep -E '^dv-.*\.md$' \
-  | sed 's/^dv-//; s/\.md$//'
-```
-
-If the list is empty, default to `marketing,engineering,gtm`. The user can
-register more via `deepvista agents register`.
-
-## Step 4 — Reason about today's plan
-
-You now have:
-
-- Yesterday's plan + appended summaries (assigned vs. shipped).
-- A 7-day rolling window of notes/todos/sessions (the *why* behind today).
-- The list of available `@<role>` subagents (the *who* of today).
-
-Produce markdown that:
-
-1. **Opens with a 2-3 sentence preamble** restating the week's arc — what's
-   in progress, what shipped yesterday, what's next.
-2. **`## Workflow today`** — a short bulleted list of cross-cutting work the
-   *main agent* will run directly (not delegated). Include `/refresh-skills`
-   if subagents are stale; surface explicit user todos; surface blockers.
-3. **One `## <role>` section per registered subagent**, each with:
-   - **1 must-do** — finishable today, traceable to a card or yesterday's
-     summary. Reference the source card id inline (e.g. `(see card-xyz)`).
-   - **0–2 stretch goals** — only if there's spare bandwidth.
-   - **Blockers** — call out anything the role can't proceed without.
-4. **`## Summary`** — leave empty (`_Subagent results land here after
-   `/deepvista run` finishes._`). The `/deepvista run` flow fills it later.
-
-Hard constraints:
-
-- Total length ≤ 600 words. Brevity beats completeness for a daily plan.
-- Every task must trace to a real card, note, or yesterday's summary —
-  never invent work. If a role has nothing genuinely ready, write
-  `- _No queued work today — the {role} specialist is free for ad-hoc
-  requests._` and move on.
-- Use the section headers (`## Workflow today`, `## <role>`, `## Summary`)
-  exactly — the `/deepvista run` slash command parses them by string match.
-
-## Step 5 — Save the plan as a DeepVista note
-
-Pipe the markdown straight into `deepvista notes create` and tag it so
-tomorrow's run finds it:
-
-```bash
-cat <<'PLAN' | deepvista notes create \
-  --title "Daily Planning $TODAY" \
-  --content-file - \
-  --tags "[\"daily-planning\",\"date:$TODAY\",\"source:agent\"]"
-# Daily Planning $TODAY
-
-<preamble>
-
-## Workflow today
-- …
-
-## marketing
-- …
-
-## engineering
-- …
-
-## Summary
-
-_Subagent results land here after `/deepvista run` finishes._
-PLAN
-```
-
-Confirm with the user before running the save (this is a write command).
-Surface the note URL — `https://app.deepvista.ai/notes/<id>` — in the
-response so they can edit any section before `/deepvista run` dispatches it.
-
-## Append a summary after `/deepvista run` finishes
-
-The slash command appends each subagent's reply onto today's note. There is
-no dedicated `append-summary` CLI — use `deepvista notes update`:
-
-```bash
-deepvista notes get <note-id>          # read current description
-# build new_description = current + "\n\n## Summary — <timestamp>\n<consolidated block>\n"
-deepvista notes update <note-id> --content-file -   # pipe new_description on stdin
-```
-
-## Quick reference
-
-| Command | Reads | Writes |
-|---|---|---|
-| `card +search "Daily Planning <date>"` | semantic search across cards | — |
-| `notes get <id>` | one note's full body | — |
-| `notes list --limit 20` | recent notes | — |
-| `card list --type todo` | recent todos | — |
-| `notes create --title ... --content-file - --tags ...` | stdin markdown | new note |
-| `notes update <id> --content-file -` | stdin markdown | replaces the note body |