feat: tracks — frontmatter directives, sidebar UI, multi-trigger

Recasts the old "track blocks" as "tracks" — directives stored in a
note's frontmatter rather than inline YAML fences and HTML-comment
target regions. The motivation is UX: the inline anatomy made notes
feel like config, leaked into the editing surface, and competed with
the writing flow. Frontmatter is invisible to the body editor, so
moving directives there reclaims the body as just markdown the user
wrote.

The runtime agent now edits the note body freely via standard
workspace tools rather than rewriting a constrained target region.
Each track's instruction names an H2 section to own; the agent
finds or creates that section, updates only its content, and
self-heals position on subsequent runs.

Triggers are now a unified array per track. cron / window / once /
event in any combination, including multi-trigger setups (the
flagship example: a priorities track that rebuilds at three
day-windows and reacts to incoming gmail / calendar events).
window is forgiving — fires once per day anywhere inside its
band — so users opening the app late in the morning still get the
morning run.

The chip-in-editor is gone. Tracks are managed from a right-side
sidebar opened by a Radio-icon button at the top-right of the
editor toolbar. Cmd+K is no longer a Copilot entry point — search-
only — pending a more intuitive invocation surface later.

Today.md ships as the flagship demo of what tracks can do, with a
versioned migration system so future template updates roll out
cleanly to existing users (existing body preserved, old version
backed up).

Copilot is tuned to listen for any signal that the user wants
something dynamic — not just the literal word "track". Strong
phrasings get acted on directly; one-off questions about decaying
information are answered first and then offered as a track. New or
edited tracks run once by default so the user immediately sees
content.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

apps/x/packages/shared/src/index.ts

@@ -9,7 +9,7 @@ export * as agentScheduleState from './agent-schedule-state.js';
 export * as serviceEvents from './service-events.js'
 export * as inlineTask from './inline-task.js';
 export * as blocks from './blocks.js';
-export * as trackBlock from './track-block.js';
+export * as track from './track.js';
 export * as promptBlock from './prompt-block.js';
 export * as frontmatter from './frontmatter.js';
 export * as bases from './bases.js';

apps/x/packages/shared/src/ipc.ts

@@ -6,7 +6,7 @@ import { LlmModelConfig } from './models.js';
 import { AgentScheduleConfig, AgentScheduleEntry } from './agent-schedule.js';
 import { AgentScheduleState } from './agent-schedule-state.js';
 import { ServiceEvent } from './service-events.js';
-import { TrackEvent } from './track-block.js';
+import { TrackEvent } from './track.js';
 import { UserMessageContent } from './message.js';
 import { RowboatApiConfig } from './rowboat-account.js';
 import { ZListToolkitsResponse } from './composio.js';
@@ -614,7 +614,7 @@ const ipcSchemas = {
   // Track channels
   'track:run': {
     req: z.object({
-      trackId: z.string(),
+      id: z.string(),
       filePath: z.string(),
     }),
     res: z.object({
@@ -625,22 +625,22 @@ const ipcSchemas = {
   },
   'track:get': {
     req: z.object({
-      trackId: z.string(),
+      id: z.string(),
       filePath: z.string(),
     }),
     res: z.object({
       success: z.boolean(),
-      // Fresh, authoritative YAML of the track block from disk.
-      // Renderer should use this for display/edit — never its Tiptap node attr.
+      // Fresh, authoritative YAML of the track from frontmatter.
+      // Renderer should use this for display/edit — never a stale cached copy.
       yaml: z.string().optional(),
       error: z.string().optional(),
     }),
   },
   'track:update': {
     req: z.object({
-      trackId: z.string(),
+      id: z.string(),
       filePath: z.string(),
-      // Partial TrackBlock updates — merged into the block's YAML on disk.
+      // Partial Track updates — merged into the entry on disk.
       // Backend is the sole writer; avoids races with scheduler/runner writes.
       updates: z.record(z.string(), z.unknown()),
     }),
@@ -652,7 +652,7 @@ const ipcSchemas = {
   },
   'track:replaceYaml': {
     req: z.object({
-      trackId: z.string(),
+      id: z.string(),
       filePath: z.string(),
       yaml: z.string(),
     }),
@@ -664,7 +664,7 @@ const ipcSchemas = {
   },
   'track:delete': {
     req: z.object({
-      trackId: z.string(),
+      id: z.string(),
       filePath: z.string(),
     }),
     res: z.object({

apps/x/packages/shared/src/track.ts

@@ -1,33 +1,54 @@
 import z from 'zod';
 
-export const TrackScheduleSchema = z.discriminatedUnion('type', [
+// ---------------------------------------------------------------------------
+// Triggers — when a track fires
+// ---------------------------------------------------------------------------
+//
+// A track can carry zero or more triggers under the `triggers:` key.
+// Each trigger is one of:
+//   - cron:   exact time, recurring
+//   - window: once per day, anywhere inside a time-of-day band
+//   - once:   one-shot at a future time
+//   - event:  driven by incoming signals (emails, calendar events, etc.)
+//
+// A track can have multiple triggers — e.g. a daily cron trigger AND an event
+// trigger. Omit `triggers` (or pass an empty array) for a manual-only track.
+// ---------------------------------------------------------------------------
+
+export const TriggerSchema = z.discriminatedUnion('type', [
     z.object({
         type: z.literal('cron').describe('Fires at exact cron times'),
         expression: z.string().describe('5-field cron expression, quoted (e.g. "0 * * * *")'),
     }).describe('Recurring at exact times'),
     z.object({
-        type: z.literal('window').describe('Fires at most once per cron occurrence, only within a time-of-day window'),
-        cron: z.string().describe('5-field cron expression, quoted'),
-        startTime: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/).describe('24h HH:MM, local time'),
-        endTime: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/).describe('24h HH:MM, local time'),
-    }).describe('Recurring within a time-of-day window'),
+        type: z.literal('window').describe('Fires once per day, anywhere inside a time-of-day band'),
+        startTime: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/).describe('24h HH:MM, local time. Also the daily cycle anchor — once the track fires after this time, it won\'t fire again until the next day.'),
+        endTime: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/).describe('24h HH:MM, local time. After this, the window is closed for the day.'),
+    }).describe('Recurring within a daily time-of-day window'),
     z.object({
         type: z.literal('once').describe('Fires once and never again'),
         runAt: z.string().describe('ISO 8601 datetime, local time, no Z suffix (e.g. "2026-04-14T09:00:00")'),
     }).describe('One-shot future run'),
-]).describe('Optional schedule. Omit entirely for manual-only tracks.');
+    z.object({
+        type: z.literal('event').describe('Fires when a matching event arrives'),
+        matchCriteria: z.string().describe('Describe the kinds of events that should consider this track for an update (e.g. "Emails about Q3 planning"). Pass 1 routing uses this to decide candidacy; the agent does Pass 2 on the event payload.'),
+    }).describe('Event-driven'),
+]);
 
-export type TrackSchedule = z.infer<typeof TrackScheduleSchema>;
+export type Trigger = z.infer<typeof TriggerSchema>;
 
-export const TrackBlockSchema = z.object({
-    trackId: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/).describe('Kebab-case identifier, unique within the note file'),
+// ---------------------------------------------------------------------------
+// Track entity
+// ---------------------------------------------------------------------------
+
+export const TrackSchema = z.object({
+    id: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/).describe('Kebab-case identifier, unique within the note file'),
     instruction: z.string().min(1).describe('What the agent should produce each run — specific, single-focus, imperative'),
-    eventMatchCriteria: z.string().optional().describe('When set, this track participates in event-based triggering. Describe what kinds of events should consider this track for an update (e.g. "Emails about Q3 planning"). Omit to disable event triggers — the track will only run on schedule or manually.'),
     active: z.boolean().default(true).describe('Set false to pause without deleting'),
-    schedule: TrackScheduleSchema.optional(),
+    triggers: z.array(TriggerSchema).optional().describe('When this track fires. A track can have multiple triggers — e.g. an hourly cron AND an event trigger. Omit (or use an empty array) for a manual-only track.'),
     model: z.string().optional().describe('ADVANCED — leave unset. Per-track LLM model override (e.g. "anthropic/claude-sonnet-4.6"). Only set when the user explicitly asked for a specific model for THIS track. The global default already picks a tuned model for tracks; overriding usually makes things worse, not better.'),
     provider: z.string().optional().describe('ADVANCED — leave unset. Per-track provider name override (e.g. "openai", "anthropic"). Only set when the user explicitly asked for a specific provider for THIS track. Almost always omitted; the global default flows through correctly.'),
-    icon: z.string().optional().describe('Lucide icon name for the chip (e.g. "clock", "calendar-days", "mail", "history", "list-todo"). Omit to use the default icon for this track.'),
+    icon: z.string().optional().describe('Lucide icon name for status display (e.g. "clock", "calendar-days", "mail", "history", "list-todo"). Omit to use the default icon for this track.'),
     lastRunAt: z.string().optional().describe('Runtime-managed — never write this yourself'),
     lastRunId: z.string().optional().describe('Runtime-managed — never write this yourself'),
     lastRunSummary: z.string().optional().describe('Runtime-managed — never write this yourself'),
@@ -59,7 +80,7 @@ export type KnowledgeEvent = z.infer<typeof KnowledgeEventSchema>;
 
 export const Pass1OutputSchema = z.object({
     candidates: z.array(z.object({
-        trackId: z.string().describe('The track block identifier'),
+        trackId: z.string().describe('The track identifier'),
         filePath: z.string().describe('The note file path the track lives in'),
     })).describe('Tracks that may be relevant to this event. trackIds are only unique within a file, so always return both fields.'),
 });
@@ -86,5 +107,5 @@ export const TrackRunCompleteEvent = z.object({
 
 export const TrackEvent = z.union([TrackRunStartEvent, TrackRunCompleteEvent]);
 
-export type TrackBlock = z.infer<typeof TrackBlockSchema>;
+export type Track = z.infer<typeof TrackSchema>;
 export type TrackEventType = z.infer<typeof TrackEvent>;