@notis_ai/cli 0.2.4 → 0.2.6

package/dist/scaffolds/notis-journal/packages/sdk/src/styles.css

@@ -0,0 +1,186 @@
+/**
+ * Notis theme CSS variables.
+ *
+ * Import this in your app layout:
+ *
+ *   import '@notis/sdk/styles.css';
+ *
+ * The portal injects the live Notis theme variables at render time.
+ */
+
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+  * {
+    @apply border-border;
+  }
+  [data-notis-app-root] {
+    color: hsl(var(--foreground));
+    display: block;
+    min-height: 100%;
+  }
+}
+
+@layer components {
+  .notis-app-shell {
+    @apply mx-auto w-full max-w-[var(--portal-page-max-width)] px-4 py-6 md:px-4 md:py-8;
+  }
+
+  .notis-app-surface {
+    @apply rounded-2xl border border-border bg-card text-card-foreground shadow-sm;
+  }
+
+  .notis-app-section {
+    @apply p-5 md:p-6;
+  }
+}
+
+/*
+ * Markdown value-type rendering (see the `Markdown` component). Plain CSS on
+ * theme variables so it works inside the portal shadow root and the dev
+ * harness without depending on the app's Tailwind content scan.
+ */
+.notis-markdown {
+  font-size: 14px;
+  line-height: 1.65;
+  color: hsl(var(--foreground));
+  overflow-wrap: break-word;
+}
+
+.notis-markdown--sm {
+  font-size: 13px;
+  line-height: 1.55;
+}
+
+.notis-markdown > :first-child {
+  margin-top: 0;
+}
+
+.notis-markdown > :last-child {
+  margin-bottom: 0;
+}
+
+.notis-markdown p {
+  margin: 0.625em 0;
+}
+
+.notis-markdown h1,
+.notis-markdown h2,
+.notis-markdown h3,
+.notis-markdown h4,
+.notis-markdown h5,
+.notis-markdown h6 {
+  margin: 1.25em 0 0.5em;
+  font-weight: 650;
+  letter-spacing: -0.01em;
+  line-height: 1.3;
+  color: hsl(var(--foreground));
+}
+
+.notis-markdown h1 { font-size: 1.5em; }
+.notis-markdown h2 { font-size: 1.25em; }
+.notis-markdown h3 { font-size: 1.1em; }
+.notis-markdown h4,
+.notis-markdown h5,
+.notis-markdown h6 { font-size: 1em; }
+
+.notis-markdown ul,
+.notis-markdown ol {
+  margin: 0.625em 0;
+  padding-left: 1.5em;
+}
+
+.notis-markdown ul { list-style-type: disc; }
+.notis-markdown ol { list-style-type: decimal; }
+
+.notis-markdown li {
+  margin: 0.25em 0;
+}
+
+.notis-markdown li > ul,
+.notis-markdown li > ol {
+  margin: 0.25em 0;
+}
+
+.notis-markdown ul.contains-task-list {
+  list-style: none;
+  padding-left: 0.375em;
+}
+
+.notis-markdown li.task-list-item input[type='checkbox'] {
+  margin-right: 0.5em;
+  accent-color: hsl(var(--primary));
+}
+
+.notis-markdown blockquote {
+  margin: 0.75em 0;
+  padding: 0.125em 0 0.125em 0.875em;
+  border-left: 3px solid hsl(var(--border));
+  color: hsl(var(--muted-foreground));
+}
+
+.notis-markdown a {
+  color: hsl(var(--primary));
+  text-decoration: underline;
+  text-decoration-color: hsl(var(--primary) / 0.35);
+  text-underline-offset: 2px;
+}
+
+.notis-markdown a:hover {
+  text-decoration-color: hsl(var(--primary));
+}
+
+.notis-markdown code {
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 0.875em;
+  padding: 0.125em 0.375em;
+  border-radius: 0.25rem;
+  background: hsl(var(--muted));
+  color: hsl(var(--foreground));
+}
+
+.notis-markdown pre {
+  margin: 0.75em 0;
+  padding: 0.75em 1em;
+  border-radius: 0.5rem;
+  background: hsl(var(--muted));
+  overflow-x: auto;
+}
+
+.notis-markdown pre code {
+  padding: 0;
+  background: transparent;
+  font-size: 0.875em;
+}
+
+.notis-markdown hr {
+  margin: 1.25em 0;
+  border: 0;
+  border-top: 1px solid hsl(var(--border));
+}
+
+.notis-markdown img {
+  max-width: 100%;
+  border-radius: 0.5rem;
+}
+
+.notis-markdown table {
+  margin: 0.75em 0;
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 0.95em;
+}
+
+.notis-markdown th,
+.notis-markdown td {
+  padding: 0.375em 0.75em;
+  border: 1px solid hsl(var(--border));
+  text-align: left;
+}
+
+.notis-markdown th {
+  background: hsl(var(--muted));
+  font-weight: 600;
+}

package/dist/scaffolds/notis-journal/packages/sdk/src/ui.ts

@@ -0,0 +1,15 @@
+/**
+ * @notis/sdk/ui - Re-exported shadcn components for Notis apps.
+ *
+ * Apps include shadcn via their own `components.json` and `@/components/ui/*`
+ * imports. This entrypoint is provided as a convenience for apps that want to
+ * import directly from the SDK without setting up shadcn locally.
+ *
+ * For now, this is a placeholder. The scaffold template sets up shadcn
+ * directly in the app project, so components come from `@/components/ui/*`.
+ * This file can be expanded later to re-export a curated set of components
+ * pre-themed for Notis.
+ */
+
+// Placeholder -- apps use shadcn directly via their project's components/ui/
+export {};

package/dist/scaffolds/notis-journal/packages/sdk/src/vite.ts

@@ -0,0 +1,56 @@
+/**
+ * Vite config builder for Notis apps.
+ *
+ * Usage:
+ * ```ts
+ * // vite.config.ts
+ * import { notisViteConfig } from '@notis/sdk/vite';
+ * import appConfig from './notis.config';
+ * export default notisViteConfig(appConfig);
+ * ```
+ *
+ * Produces a library-mode ES module bundle with React externalized.
+ * Output: .notis/output/bundle/app.js + app.css
+ */
+
+import type { NotisAppConfig } from './config';
+
+export function notisViteConfig(appConfig: NotisAppConfig) {
+  return {
+    plugins: [
+      // @vitejs/plugin-react is added by the consumer's vite.config.ts
+      // or auto-detected. We provide the config shape only.
+    ],
+    build: {
+      lib: {
+        entry: '.notis/_entry.tsx',
+        formats: ['es'] as const,
+        fileName: () => 'app.js',
+      },
+      rollupOptions: {
+        external: ['react', 'react-dom', 'react-dom/client', 'react/jsx-runtime', 'react/jsx-dev-runtime'],
+        output: {
+          globals: {
+            react: 'window.React',
+            'react-dom': 'window.ReactDOM',
+            'react-dom/client': 'window.ReactDOMClient',
+            'react/jsx-runtime': 'window.React',
+          },
+          assetFileNames: 'app[extname]',
+          inlineDynamicImports: true,
+        },
+      },
+      outDir: '.notis/output/bundle',
+      emptyOutDir: true,
+      cssCodeSplit: false,
+    },
+    resolve: {
+      alias: {
+        '@': process.cwd(),
+      },
+    },
+    define: {
+      'process.env.NODE_ENV': JSON.stringify('production'),
+    },
+  };
+}

package/dist/scaffolds/notis-journal/packages/sdk/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

package/dist/scaffolds/notis-journal/postcss.config.mjs

@@ -0,0 +1,8 @@
+/** @type {import('postcss-load-config').Config} */
+const config = {
+  plugins: {
+    tailwindcss: {},
+  },
+};
+
+export default config;

package/dist/scaffolds/notis-journal/skills/journal-onboarding/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: journal-onboarding
+description: "Set up the Journal morning and evening automations and run their check-ins. Use when onboarding someone to the Journal daily practice, changing their check-in schedule, or when a Journal automation asks to run the morning or evening check-in."
+---
+
+# Journal Daily Practice
+
+The Journal is a five-minute daily practice captured entirely in conversation. Notis asks, the user answers, and the `journal_entries` database fills itself — the app only displays. There are two rituals:
+
+- **Morning check-in** — waking mood (1–7 pleasant scale + one adjective), how they're feeling, energy (1–10), motivation (1–10), three gratitudes, an intention for the day, and a daily affirmation.
+- **Evening reflection** — whole-day mood (1–7 pleasant scale + one adjective), the day's highlight, what the day taught them, a gentle catch-up of anything the morning missed, and an optional free-form entry.
+
+## Choose the Mode
+
+- Use **setup mode** when the user is onboarding, asks to configure Journal check-ins, or wants to change the schedule.
+- Use **morning-check mode** only when the request or automation prompt names it.
+- Use **evening-check mode** only when the request or automation prompt names it.
+- Never enter setup mode from a check-in run.
+
+## Tone (applies to every mode)
+
+Write like a warm, attentive companion — closer to a good therapist than to a form. Concrete rules:
+
+- Sound like a person, not a survey. Weave the questions into one or two short messages instead of a numbered interrogation.
+- Reference what they actually said, today or on recent days, when it helps ("this morning you said the demo had you excited — how did it go?").
+- Never guilt-trip about missed days or missing fields. A skipped question is an answer; move on gracefully.
+- Accept partial answers. Save what was given; the evening pass picks up morning leftovers, and anything still missing after that just stays blank.
+- Keep it light: this is a check-in, not a medical assessment. Never diagnose, never analyze the user unprompted.
+
+## The Pleasant Scale
+
+Both moods use the same 1–7 scale (like Apple's State of Mind): 1 very unpleasant, 2 unpleasant, 3 slightly unpleasant, 4 neutral, 5 slightly pleasant, 6 pleasant, 7 very pleasant.
+
+- Ask for it conversationally ("where does this morning land, 1 to 7, unpleasant to pleasant?") and store the integer.
+- If the user answers with words only ("pretty good"), map it yourself (pretty good ≈ 5–6), confirm implicitly by restating ("logging that as a 6"), and store it.
+- The adjective is the user's own word ("foggy", "electric", "flat") — store it lower-case in the matching `... Mood Word` property. If they give a sentence, pull the strongest adjective and keep the sentence in `Morning Feeling` (morning) or the free entry (evening).
+
+## Writing to the Database
+
+The native Notis database with slug `journal_entries` holds **one entry per local calendar day**:
+
+- Find today's entry with `LOCAL_NOTIS_DATABASE_QUERY` and a structured filter on **Date** for the user's local day. Ignore archived entries. If duplicates exist, use the most recently updated one and mention the duplicate briefly; never merge or delete.
+- Create it only if it does not exist, via `LOCAL_NOTIS_DATABASE_UPSERT_JOURNAL_ENTRIES` with `Name` = `Journal — YYYY-MM-DD` (local date) and `Date` = that day.
+- Update by passing only the properties the user just answered. Never overwrite a field that already has a value unless the user explicitly corrects it.
+- Properties: `Morning Mood` (1–7), `Morning Mood Word`, `Morning Feeling`, `Energy` (1–10), `Motivation` (1–10), `Gratitude 1..3`, `Intention`, `Affirmation`, `Day Mood` (1–7), `Day Mood Word`, `Highlight`, `Lesson`.
+- The optional free-form entry goes in the document body: pass `content_markdown` (append to existing content rather than replacing it; set `replace` only when the body is empty).
+
+## Setup Mode
+
+### 1. Recommend the Routine
+
+Briefly explain the two automations before asking for times:
+
+- A **morning check-in** (recommend ~08:00) captures the waking mood, energy, motivation, gratitudes, intention, and affirmation while the day is still fresh.
+- An **evening reflection** (recommend ~21:30) captures how the day actually felt, its highlight and lesson, catches up anything the morning missed, and offers space for a free entry.
+
+Make clear both times are theirs to choose.
+
+### 2. Ask for the Schedule
+
+One compact question collecting: morning time, evening time, days of the week (default every day), timezone (unless confidently known), and delivery channel only when ambiguous. Do not create anything while any of these is unresolved.
+
+### 3. Check Existing Setup
+
+Use `LOCAL_NOTIS_LIST_REMINDERS` and `LOCAL_NOTIS_LIST_AUTOMATIONS` before writing anything — one full page of up to 100 items each, inspected locally, directly in the current assistant (no sub-agents, no repeated searches).
+
+- Match existing items by purpose, not only name. Update a matching Journal morning or evening item instead of duplicating it.
+- If an old Journal **reminder** exists from a previous version of this practice, replace it: create the morning automation and remove only that confirmed Journal reminder.
+- Preserve unrelated reminders and automations.
+
+### 4. Confirm Before Creating
+
+Recap both local schedules, days, timezone, channel, and what each check-in will ask. Obtain explicit confirmation before creating or updating anything.
+
+### 5. Create the Two Automations
+
+Use `LOCAL_NOTIS_INSERT_AUTOMATION` (or `LOCAL_NOTIS_UPDATE_AUTOMATION` for a matching existing item) for **both** check-ins:
+
+- Names: `Journal morning check-in` and `Journal evening reflection`.
+- `schedule` triggers with standard five-field cron expressions derived from the confirmed local times and days. Recurrence lives only in `cron_expression`.
+- Delivery only via `channel` and, when required, `channel_account_id`.
+- **Enable cross-run context on both automations.** The evening reflection must see the morning conversation so it can follow up on what the user actually said — this consolidated thread is a core feature of the practice, not an option.
+- Morning prompt, exactly:
+
+  `Run /journal-onboarding in morning-check mode: hold this morning's Journal check-in and save the answers to today's journal_entries entry.`
+
+- Evening prompt, exactly:
+
+  `Run /journal-onboarding in evening-check mode: review today's journal_entries entry, hold the evening reflection, follow up on what the morning conversation actually said, and save the answers.`
+
+Do not put scheduling or delivery instructions inside the prompts.
+
+### 6. Report the Result
+
+Return a concise summary: both local schedules, the delivery channel, created vs updated for each item, and the automation IDs or portal links. The native tools store recurring schedules as UTC cron expressions — convert from the user's IANA timezone, then verify the returned crons and the Portal-rendered local times. That read-back completes setup verification; do not launch extra agents or investigate scheduler internals.
+
+## Morning-Check Mode
+
+1. Find (or note the absence of) today's entry as described in *Writing to the Database*.
+2. Open with one short, warm greeting that folds in the first questions. Cover, across at most two messages: waking mood (scale + their word), how they're feeling, energy and motivation (1–10 each), three gratitudes, what would make today great, and a daily affirmation.
+3. If they stall on the affirmation, offer to shape one from what they just said — their words, not a canned quote.
+4. Create or update today's entry with everything captured. Partial is fine; say nothing about the gaps (the evening picks them up).
+5. Close in one line that reflects their intention back ("holding you to that walk — talk tonight").
+
+## Evening-Check Mode
+
+1. Read today's entry. Its filled fields plus the morning conversation (available through the automation's shared context) are your material.
+2. Open by connecting to the morning — reference a real detail, then ask the evening questions. Example shape: "Evening — this morning you were grateful for the calm before the demo. Did that calm hold? How did the whole day feel, 1 to 7, and what one word would you give it?"
+3. Cover: day mood (scale + adjective), highlight of the day, what the day taught them.
+4. Then gently flag what the morning missed, grouped in one soft sentence ("we never got to your three gratitudes this morning — anything from today count?"). Ask only for genuinely missing fields; never re-ask populated ones.
+5. Offer the optional free entry last, as an open door, not a task ("anything else about today you want kept? I'll write it down word for word").
+6. Save all answers (properties + `content_markdown` for the free entry). If no entry exists at all, create it and run the whole check-in as a compact evening version.
+7. If every field is already complete, just reflect the day back in a sentence and say goodnight — no questions.
+
+## Guardrails
+
+- Never create a second copy of the same automation, reminder, or daily entry.
+- Never schedule anything without confirmed times, timezone, days, and destination.
+- Never invent values the user did not give; never delete entries; never rewrite an existing free entry (append only).
+- Never turn a check-in prompt into instructions to create another automation.

package/dist/scaffolds/notis-journal/src/dev-main.tsx

@@ -0,0 +1,58 @@
+import { StrictMode, useEffect, useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import { NotisProvider } from '@notis/sdk';
+import AppShell from '../app/layout';
+import JournalPage from '../app/page';
+import InsightsPage from '../app/insights/page';
+import { installMockRuntime } from './mock-runtime';
+
+const runtime = installMockRuntime();
+
+function DevPreview() {
+  const [route, setRoute] = useState<'journal' | 'insights'>('journal');
+
+  useEffect(() => {
+    const onNav = (e: Event) => {
+      const detail = (e as CustomEvent).detail as { path?: string };
+      if (detail?.path?.includes('insights')) setRoute('insights');
+      else if (detail?.path === '/') setRoute('journal');
+    };
+    window.addEventListener('mock-navigate', onNav);
+    return () => window.removeEventListener('mock-navigate', onNav);
+  }, []);
+
+  return (
+    <div data-dev-preview className="min-h-screen bg-background text-foreground">
+      <div className="flex items-center gap-2 border-b border-border bg-card px-4 py-2 text-xs">
+        <span className="font-semibold text-muted-foreground">Dev preview</span>
+        {(['journal', 'insights'] as const).map((r) => (
+          <button
+            key={r}
+            type="button"
+            onClick={() => setRoute(r)}
+            className={
+              'rounded-md px-2.5 py-1 font-medium capitalize ' +
+              (route === r ? 'bg-primary text-primary-foreground' : 'text-muted-foreground hover:bg-muted')
+            }
+          >
+            {r}
+          </button>
+        ))}
+      </div>
+      {route === 'journal' ? <JournalPage /> : <InsightsPage />}
+    </div>
+  );
+}
+
+const root = document.getElementById('root');
+if (!root) throw new Error('#root element missing from index.html');
+
+createRoot(root).render(
+  <StrictMode>
+    <NotisProvider runtime={runtime}>
+      <AppShell>
+        <DevPreview />
+      </AppShell>
+    </NotisProvider>
+  </StrictMode>,
+);

package/dist/scaffolds/notis-journal/src/mock-runtime.ts

@@ -0,0 +1,197 @@
+import type { NotisRuntime } from '@notis/sdk';
+
+/** Build Notion-shape property values, mirroring what the portal runtime returns. */
+function text(content: string) {
+  return { type: 'rich_text', rich_text: [{ type: 'text', text: { content } }] };
+}
+function date(iso: string) {
+  return { type: 'date', date: { start: iso, end: '', timezone: null } };
+}
+function number(n: number) {
+  return { type: 'number', number: n };
+}
+function title(content: string) {
+  return { type: 'title', title: [{ type: 'text', text: { content } }] };
+}
+
+function dayISO(offset: number): string {
+  const d = new Date();
+  d.setDate(d.getDate() - offset);
+  d.setHours(8, 0, 0, 0);
+  return d.toISOString();
+}
+
+type Seed = {
+  offset: number;
+  morningMood?: number;
+  morningWord?: string;
+  feeling?: string;
+  energy?: number;
+  motivation?: number;
+  gratitudes?: [string, string, string] | [string, string] | [string];
+  intention?: string;
+  affirmation?: string;
+  dayMood?: number;
+  dayWord?: string;
+  highlight?: string;
+  lesson?: string;
+  freeEntry?: string;
+};
+
+const SEEDS: Seed[] = [
+  {
+    offset: 0,
+    morningMood: 6,
+    morningWord: 'rested',
+    feeling: 'Calm and a little excited about the demo this afternoon.',
+    energy: 8,
+    motivation: 9,
+    gratitudes: [
+      'A slow coffee on the balcony before anyone was awake',
+      'Camille laughing at my terrible pun last night',
+      'That my back finally feels normal again',
+    ],
+    intention: 'One deep-work block on the launch page before opening messages.',
+    affirmation: 'I am allowed to do one thing at a time.',
+    // Evening not captured yet — today.
+  },
+  {
+    offset: 1,
+    morningMood: 4,
+    morningWord: 'foggy',
+    feeling: 'Slept badly, brain still booting.',
+    energy: 4,
+    motivation: 6,
+    gratitudes: [
+      'Rain on the window while working',
+      'The boulangerie was still open at 19:30',
+      'A friend checking in for no reason',
+    ],
+    intention: 'Keep the day small: ship the fix, walk at lunch.',
+    affirmation: 'I am steady even on slow days.',
+    dayMood: 6,
+    dayWord: 'redeemed',
+    highlight: 'The afternoon walk turned into an hour of ideas with Théo.',
+    lesson: 'A rough morning predicts nothing about the afternoon.',
+    freeEntry:
+      'Started the day convinced it was a write-off. By 16:00 the fix was shipped and the walk with Théo unknotted the roadmap question that has been bugging me for a week. Note to self: leave the house earlier.',
+  },
+  {
+    offset: 2,
+    morningMood: 7,
+    morningWord: 'sunny',
+    feeling: 'Woke up before the alarm, ready to go.',
+    energy: 9,
+    motivation: 9,
+    gratitudes: [
+      'Eight hours of sleep, finally',
+      'The new espresso beans',
+      'A clear calendar until noon',
+    ],
+    intention: 'Finish the investor update and actually send it.',
+    affirmation: 'I am building something worth the patience it takes.',
+    dayMood: 7,
+    dayWord: 'unstoppable',
+    highlight: 'Sent the update and got two warm replies within the hour.',
+    lesson: 'Momentum compounds when I front-load the scary task.',
+  },
+  {
+    offset: 3,
+    morningMood: 3,
+    morningWord: 'heavy',
+    feeling: 'Anxious about the support backlog.',
+    energy: 3,
+    motivation: 4,
+    gratitudes: [
+      'Tea instead of a third coffee',
+      'The cat sleeping on my desk all morning',
+    ],
+    intention: 'Answer ten tickets, then stop counting.',
+    affirmation: 'I am more than my inbox.',
+    dayMood: 4,
+    dayWord: 'okay',
+    highlight: 'Closed the hardest ticket with an actual fix, not a workaround.',
+    lesson: 'Naming the dread out loud makes it about half as loud.',
+  },
+  {
+    offset: 4,
+    morningMood: 5,
+    morningWord: 'curious',
+    feeling: 'Mildly under-slept but interested in the day.',
+    energy: 6,
+    motivation: 7,
+    gratitudes: [
+      'Morning light in the kitchen',
+      'A podcast that made the dishes disappear',
+      'Knowing exactly what today is for',
+    ],
+    intention: 'Prototype the stats page before lunch.',
+    affirmation: 'I am learning fast enough.',
+    dayMood: 6,
+    dayWord: 'satisfying',
+    highlight: 'The prototype clicked on the third try.',
+    lesson: 'The second draft is where the good ideas live.',
+    freeEntry: 'Quiet, focused day. The kind that does not make stories but makes progress.',
+  },
+];
+
+function buildDocuments() {
+  return SEEDS.map((s, i) => {
+    const iso = dayISO(s.offset);
+    const properties: Record<string, unknown> = {
+      Name: title(`Journal — ${iso.slice(0, 10)}`),
+      Date: date(iso),
+    };
+    if (s.morningMood != null) properties['Morning Mood'] = number(s.morningMood);
+    if (s.morningWord) properties['Morning Mood Word'] = text(s.morningWord);
+    if (s.feeling) properties['Morning Feeling'] = text(s.feeling);
+    if (s.energy != null) properties['Energy'] = number(s.energy);
+    if (s.motivation != null) properties['Motivation'] = number(s.motivation);
+    (s.gratitudes ?? []).forEach((g, gi) => {
+      properties[`Gratitude ${gi + 1}`] = text(g);
+    });
+    if (s.intention) properties['Intention'] = text(s.intention);
+    if (s.affirmation) properties['Affirmation'] = text(s.affirmation);
+    if (s.dayMood != null) properties['Day Mood'] = number(s.dayMood);
+    if (s.dayWord) properties['Day Mood Word'] = text(s.dayWord);
+    if (s.highlight) properties['Highlight'] = text(s.highlight);
+    if (s.lesson) properties['Lesson'] = text(s.lesson);
+    return {
+      id: `mock_${i}`,
+      title: `Journal — ${iso.slice(0, 10)}`,
+      content_markdown: s.freeEntry ?? '',
+      created_time: iso,
+      properties,
+    };
+  });
+}
+
+export function installMockRuntime(): NotisRuntime {
+  const documents = buildDocuments();
+  return {
+    app: { id: 'mock', name: '5 Minutes Journal', slug: 'notis-journal', icon: 'phosphor:notebook' } as never,
+    route: { path: '/', slug: 'journal', name: 'Journal' } as never,
+    databases: [] as never,
+    context: {},
+    navigate: (payload) => {
+      // eslint-disable-next-line no-console
+      console.log('[mock navigate]', payload);
+      window.dispatchEvent(new CustomEvent('mock-navigate', { detail: payload }));
+    },
+    registerTopBarSearch: () => {},
+    setTopBarSearchValue: () => {},
+    setTopBarSearchLoading: () => {},
+    async listTools() {
+      return [];
+    },
+    async callTool(name: string) {
+      if (name === 'LOCAL_NOTIS_DATABASE_QUERY') {
+        return { documents } as never;
+      }
+      return {} as never;
+    },
+    async request() {
+      return {};
+    },
+  };
+}