granttap-mcp 0.8.115 → 0.8.116

package/THIRD_PARTY_LICENSES.txt

@@ -2737,3 +2737,33 @@ ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+smol-toml 1.9.1 — BSD-3-Clause
+Source: https://www.npmjs.com/package/smol-toml/v/1.9.1
+Notices: fa5659948374d4f555594f47f6da073b40dc503e921aeeece30df4362b3051a5
+
+Copyright (c) Squirrel Chat et al., All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/THIRD_PARTY_NOTICES.md

@@ -20,6 +20,7 @@ boundaries and upstream grants remain separate from GrantTap's first-party comme
 | `tweetnacl` | The Unlicense |
 | `ws` | MIT |
 | `zod` | MIT |
+| `smol-toml` | BSD-3-Clause |
 
 The unpublished Rust workspace also depends on separately licensed components,
 including `mcport` (MIT), `blazingly-json` (MIT), `serde` (MIT OR Apache-2.0), and

package/apps/bridge/src/host/session-keys.ts

@@ -83,6 +83,7 @@ async function sendScopedPayload(input: {
     key,
     purpose,
     createdAt: Date.now(),
-  }, to, { ttlMs: options.ttlMs, peerPublicKey: options.peerPublicKey, ...grantOptions });
+  }, to, { ttlMs: options.ttlMs, peerPublicKey: options.peerPublicKey,
+    ...(options.urgent ? { urgent: true } : {}), ...grantOptions });
   await client.sendSession(payload, sessionId, to, options);
 }

package/apps/bridge/src/monitor/handlers/inbound.ts

@@ -1,5 +1,6 @@
 import { handleTaskTransferCommand } from "../../task-transfer/runtime";
 import { handleDeviceManagement } from '../../device-management';
+import { handleTaskSchedules } from '../../task-schedules/relay';
 import { handleProjectTransportConfiguration } from '../../task-network/runtime';
 import { handleHookTrust } from "../../codex-hook-trust";
 import { handleConfigurationCommand } from "../../configuration-delivery";
@@ -69,6 +70,7 @@ export async function handleMonitorMessage(
     if (!leadership.acquire()) return false;
     const configuration = handlePeerConfiguration(client, payload, input.peerPublicKey, publish);
     if (configuration) return configuration;
+    if (payload.type === 'task.schedules') return handleTaskSchedules(client, payload, input.peerPublicKey);
     if (payload.type === "knowledge.write") {
       return handleInboundKnowledgeWrite(client, payload, input.peerPublicKey, publish);
     }

package/apps/bridge/src/monitor/support/heartbeat.ts

@@ -20,7 +20,8 @@ export const HEARTBEAT_INTERVAL_MS = Number(
  */
 export async function publishHeartbeat(client: RelayClient): Promise<void> {
   await client.send(
-    { type: "machine.heartbeat", machine: computerDisplayName(), createdAt: Date.now(), taskQueueImmediate: true },
+    { type: "machine.heartbeat", machine: computerDisplayName(), createdAt: Date.now(), taskQueueImmediate: true,
+      taskScheduleControls: true },
     "phone",
     { ttlMs: HEARTBEAT_INTERVAL_MS * 3, reliable: false },
   );
@@ -38,7 +39,8 @@ export const HELD_HEARTBEAT_TTL_MS = 60_000;
 
 export async function publishHeldHeartbeat(client: RelayClient): Promise<void> {
   await client.send(
-    { type: "machine.heartbeat", machine: computerDisplayName(), createdAt: Date.now(), taskQueueImmediate: true },
+    { type: "machine.heartbeat", machine: computerDisplayName(), createdAt: Date.now(), taskQueueImmediate: true,
+      taskScheduleControls: true },
     "phone",
     { ttlMs: HELD_HEARTBEAT_TTL_MS, reliable: true },
   );

package/apps/bridge/src/providers/grok-catalog-cache/README.md

@@ -0,0 +1,8 @@
+# Grok catalog cache
+
+Public entry: `GrokCatalogCache`. Cache only the parsed native inputs belonging
+to the current admitted scan. Model-context files and visible update streams
+have separate fingerprints, so streaming text does not decode an unchanged
+context again. A complete export bypasses this catalog cache.
+
+First-party code is under the GrantTap Commercial Source License.

package/apps/bridge/src/providers/grok-catalog-cache/index.ts

@@ -0,0 +1,74 @@
+import { statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import type { ActivityEntry } from '../../../../../packages/protocol/schema';
+import type { CapabilityObservation } from '../../sessions/telemetry';
+
+export type GrokParsedContext = { entries: ActivityEntry[]; usage: CapabilityObservation[];
+  firstUser?: string; lastMessageAt?: number; tokens: number; lastTurn: number; cacheable?: boolean };
+type Source = { fingerprint: string; present: boolean };
+type Entry = { contextFingerprint: string; updateFingerprint?: string; context: GrokParsedContext;
+  omittedContextEntries: boolean; visible?: ActivityEntry[]; result: GrokParsedContext };
+type Identity = { directory: string; sessionId: string; fallbackTime: number };
+
+function source(identity: Identity, names: string[]): Source | undefined {
+  let present = false;
+  const stamps: string[] = [identity.sessionId, String(identity.fallbackTime)];
+  try {
+    for (const name of names) {
+      try {
+        const stat = statSync(join(identity.directory, name), { bigint: true });
+        present = true;
+        stamps.push([name, stat.dev, stat.ino, stat.size, stat.mtimeNs, stat.ctimeNs].map(String).join(':'));
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+        stamps.push(name + ':missing');
+      }
+    }
+    return { fingerprint: JSON.stringify(stamps), present };
+  } catch { return undefined; }
+}
+
+export function withGrokVisible(context: GrokParsedContext, visible: ActivityEntry[] | undefined): GrokParsedContext {
+  if (visible === undefined) return context;
+  let firstUser = context.firstUser, lastMessageAt = context.lastMessageAt ?? 0;
+  for (const entry of visible) {
+    if (entry.kind === 'user') firstUser ??= entry.text.trim().slice(0, 120);
+    if (['user', 'message', 'final'].includes(entry.kind)) lastMessageAt = Math.max(lastMessageAt, entry.createdAt);
+  }
+  return { ...context, entries: visible, firstUser, lastMessageAt: lastMessageAt || undefined };
+}
+
+/** Retain only the current scan's sources; context and the native visible stream advance independently. */
+export class GrokCatalogCache {
+  private readonly entries = new Map<string, Entry>();
+
+  retain(directories: ReadonlySet<string>): void {
+    const keep = new Set([...directories].map(path => resolve(path)));
+    for (const key of this.entries.keys()) if (!keep.has(key)) this.entries.delete(key);
+  }
+
+  read(identity: Identity, load: { context: () => GrokParsedContext; visible: () => ActivityEntry[] | undefined }): GrokParsedContext {
+    const key = resolve(identity.directory), previous = this.entries.get(key);
+    const contextSource = source(identity, ['chat_history.jsonl', 'events.jsonl', 'rewind_points.jsonl']);
+    const updateSource = source(identity, ['updates.jsonl']);
+    const sameContext = contextSource != null && previous?.contextFingerprint === contextSource.fingerprint;
+    const sameUpdates = updateSource != null && previous?.updateFingerprint === updateSource.fingerprint;
+    if (sameContext && sameUpdates) return previous!.result;
+    const loadedVisible = sameUpdates ? undefined : load.visible();
+    const visible = sameUpdates ? previous!.visible
+      : loadedVisible === undefined ? undefined : structuredClone(loadedVisible);
+    const context = sameContext && !(visible === undefined && previous!.omittedContextEntries)
+      ? previous!.context : load.context();
+    const result = withGrokVisible(context, visible);
+    const unchangedContext = contextSource != null && contextSource.fingerprint
+      === source(identity, ['chat_history.jsonl', 'events.jsonl', 'rewind_points.jsonl'])?.fingerprint;
+    const unchangedUpdates = updateSource != null && updateSource.fingerprint === source(identity, ['updates.jsonl'])?.fingerprint;
+    if (unchangedContext && unchangedUpdates && context.cacheable !== false) {
+      this.entries.set(key, { contextFingerprint: contextSource!.fingerprint,
+        updateFingerprint: visible !== undefined || !updateSource!.present ? updateSource!.fingerprint : undefined,
+        context: visible !== undefined ? { ...context, entries: [] } : context,
+        omittedContextEntries: visible !== undefined, visible, result });
+    }
+    return result;
+  }
+}

package/apps/bridge/src/sessions/scan/grok.ts

@@ -21,6 +21,7 @@ import { grokNativeActivity } from '../../providers/grok-activity';
 import { grokTimeline } from '../../providers/grok-timeline';
 import { grokToolCalls, grokToolCompletions, grokToolSummary, grokRecordedChanges } from '../../providers/grok-tools';
 import { readGrokConversation } from '../../providers/grok-conversation';
+import { GrokCatalogCache, type GrokParsedContext } from '../../providers/grok-catalog-cache';
 
 type Summary = {
   info?: { id?: unknown; cwd?: unknown };
@@ -31,15 +32,7 @@ type Summary = {
   current_model_id?: unknown;
 };
 
-type ParsedLog = {
-  entries: ActivityEntry[];
-  usage: CapabilityObservation[];
-  firstUser?: string;
-  lastMessageAt?: number;
-  tokens: number;
-  lastTurn: number;
-};
-
+const catalogCache = new GrokCatalogCache();
 let activityBySession = new Map<string, ActivityEntry[]>();
 let logPaths = new Map<string, string>();
 let usageBySession = new Map<string, CapabilityObservation[]>();
@@ -84,9 +77,14 @@ function visibleRole(row: Record<string, unknown>, message: Record<string, unkno
   return typeof type === "string" ? type : "";
 }
 
-function parseLog(path: string, sessionId: string, fallbackTime: number, fullText = false): ParsedLog {
+function parseLog(path: string, sessionId: string, fallbackTime: number, fullText = false): GrokParsedContext {
   let lines: string[];
-  try { lines = readFileSync(path, "utf8").split("\n"); } catch { lines = []; }
+  let cacheable = true;
+  try { lines = readFileSync(path, "utf8").split("\n"); }
+  catch (error) {
+    if (fullText && (error as NodeJS.ErrnoException).code !== 'ENOENT') throw Error('The complete Grok conversation could not be read.');
+    lines = []; cacheable = (error as NodeJS.ErrnoException).code === 'ENOENT';
+  }
   const entries: ActivityEntry[] = [];
   const usage: CapabilityObservation[] = [];
   const seen = new Set<string>();
@@ -99,7 +97,10 @@ function parseLog(path: string, sessionId: string, fallbackTime: number, fullTex
   let prompt: { at: number; row: number } | undefined;
   lines.forEach((line, index) => {
     const row = safeParse(line);
-    if (!row) return;
+    if (!row) {
+      if (fullText && line.trim()) throw Error('The full native Grok conversation is incomplete or still being written.');
+      return;
+    }
     const message = row.message && typeof row.message === "object" ? row.message : row;
     const role = visibleRole(row, message);
     if (role === "reasoning" || role === "system") return;
@@ -118,7 +119,7 @@ function parseLog(path: string, sessionId: string, fallbackTime: number, fullTex
       const text = texts.join("\n").trim();
       if (text) {
         if (messageAt || prompt) lastMessageAt = Math.max(lastMessageAt, createdAt);
-        firstUser ??= text;
+        firstUser ??= text.slice(0, 120);
         pushEntry({ fullText, out: entries, seen, sessionId, kind: "user", text, createdAt, ordinal: index,
           idOverride: `${sessionId}:${legacyTime}:${index}` });
         tokens += estimateTokens(text);
@@ -162,13 +163,7 @@ function parseLog(path: string, sessionId: string, fallbackTime: number, fullTex
     last.kind = 'final'; last.createdAt = timeline.completedAt;
     lastMessageAt = Math.max(lastMessageAt, timeline.completedAt);
   }
-  const visible = readGrokConversation(dirname(path), sessionId, fullText) ?? entries;
-  for (const entry of visible) {
-    if (entry.kind === 'user') firstUser ??= entry.text;
-    if (['user', 'message', 'final'].includes(entry.kind)) lastMessageAt = Math.max(lastMessageAt, entry.createdAt);
-  }
-  return { entries: visible,
-    usage, firstUser, lastMessageAt: lastMessageAt || undefined, tokens, lastTurn };
+  return { entries, usage, firstUser, lastMessageAt: lastMessageAt || undefined, tokens, lastTurn, cacheable };
 }
 
 function parseSummary(path: string): Summary | null {
@@ -181,6 +176,10 @@ export function scanGrok(maxFiles = MAX_FILES): Scan {
   const usages = new Map<string, CapabilityObservation[]>();
   let tokensRecent = 0;
   const listed = recentSummaries(grokSessionsRoot(), maxFiles + 1);
+  logPaths = new Map();
+  const selected = new Set(listed.slice(0, maxFiles).map(path => dirname(path)));
+  catalogCache.retain(selected);
+  const admitted = new Set<string>();
   for (const path of listed.slice(0, maxFiles)) {
     const summary = parseSummary(path);
     if (!summary) continue;
@@ -188,13 +187,17 @@ export function scanGrok(maxFiles = MAX_FILES): Scan {
     const sessionId = typeof summary.info?.id === "string"
       ? summary.info.id : basename(directory);
     if (!sessionId || sessionId.length > 256) continue;
+    admitted.add(directory);
     let stat;
     try { stat = statSync(join(directory, "chat_history.jsonl")); } catch {
       try { stat = statSync(path); } catch { continue; }
     }
     const updatedAt = ts(summary.updated_at) || stat.mtimeMs;
     const startedAt = ts(summary.created_at) || stat.birthtimeMs || updatedAt;
-    const parsed = parseLog(join(directory, "chat_history.jsonl"), sessionId, startedAt);
+    const parsed = catalogCache.read({ directory, sessionId, fallbackTime: startedAt }, {
+      context: () => parseLog(join(directory, 'chat_history.jsonl'), sessionId, startedAt),
+      visible: () => readGrokConversation(directory, sessionId),
+    });
     const title = [summary.generated_title, summary.session_summary, parsed.firstUser]
       .find((value): value is string => typeof value === "string" && value.trim().length > 0);
     const cwd = typeof summary.info?.cwd === "string" ? summary.info.cwd : undefined;
@@ -213,6 +216,7 @@ export function scanGrok(maxFiles = MAX_FILES): Scan {
     if (Date.now() - updatedAt <= TOKEN_WINDOW_MS) tokensRecent += parsed.tokens;
   }
   activityBySession = activities;
+  catalogCache.retain(admitted);
   usageBySession = usages;
   return { sessions, tokensRecent, sourceLimited: listed.length > maxFiles };
 }
@@ -220,7 +224,11 @@ export function scanGrok(maxFiles = MAX_FILES): Scan {
 export function grokActivity(session: SessionInfo, fullText = false): ActivityEntry[] {
   if (!activityBySession.has(session.sessionId)) scanGrok();
   const path = logPaths.get(session.sessionId);
-  if (fullText && path) return parseLog(path, session.sessionId, session.startedAt, true).entries;
+  if (fullText && path) {
+    const native = readGrokConversation(dirname(path), session.sessionId, true);
+    if (native !== undefined) return structuredClone(native);
+    return parseLog(path, session.sessionId, session.startedAt, true).entries;
+  }
   return activityBySession.get(session.sessionId) ?? [];
 }
 

package/apps/bridge/src/task-schedules/README.md

@@ -0,0 +1,23 @@
+# Task schedules
+
+Public entry: `handleTaskSchedules`. The paired controller lists and edits existing
+Codex heartbeat automations attached to admitted executions of the same Task and
+Project. GrantTap does not create a scheduler or start provider turns here.
+
+The local Codex version-1 mirror and native scheduling row must agree. Updates
+preserve unknown fields and execution settings, use an expected revision, retain
+private before/proposed checkpoints, and roll back the mirror if the native
+transaction fails. Cloud migration, ambiguous databases, unsupported storage and
+native edits make controls read-only. Pause removes future scheduling without
+cancelling a running turn. Intervals use elapsed time; wall-clock rules use the
+computer's time zone. There is no background polling.
+
+Requests expire, repeat identities cannot repeat mutations, and replies go only
+to the requesting paired controller under the chat's key. Content and identifiers
+are bounded. Checkpoints remain private computer data, not disposable cache.
+
+Tests beside this entry exercise native persistence, rollback, external changes,
+scope, authenticated routing, lost receipts and repeated taps using isolated stores.
+
+License: first-party code is under the GrantTap Commercial Source License in the repository LICENSE.
+Third-party dependencies retain their own licenses and notices.

package/apps/bridge/src/task-schedules/cadence/README.md

@@ -0,0 +1,9 @@
+# Native schedule cadence
+
+Public entry: `validateScheduleRule` and `nextNativeOccurrence`. Accept the exact
+minute/hour interval and daily/weekly wall-clock forms editable by the phone.
+Compute only the next native timestamp when explicitly enabling or changing a
+schedule. This module owns no timer and never executes a Task. The computer's
+civil time handles daylight-saving changes; elapsed intervals remain durations.
+
+First-party code is under the GrantTap Commercial Source License.

package/apps/bridge/src/task-schedules/cadence/index.ts

@@ -0,0 +1,43 @@
+type Schedule = { frequency: string; interval: number; hour: number; minute: number; days: Set<string> };
+
+function parse(rule: string): Schedule | undefined {
+  const pairs = rule.replace(/^RRULE:/, '').split(';').map(part => part.split('='));
+  if (pairs.some(pair => pair.length !== 2)) return undefined;
+  const fields = new Map(pairs.map(([key, value]) => [key!, value!]));
+  if (fields.size !== pairs.length) return undefined;
+  const frequency = fields.get('FREQ') ?? '', intervalText = fields.get('INTERVAL') ?? '1';
+  if (!/^[1-9]\d{0,3}$/.test(intervalText)) return undefined;
+  const interval = Number(intervalText);
+  if (['MINUTELY', 'HOURLY'].includes(frequency)) {
+    return [...fields.keys()].every(key => ['FREQ', 'INTERVAL'].includes(key))
+      ? { frequency, interval, hour: 0, minute: 0, days: new Set() } : undefined;
+  }
+  if (!['DAILY', 'WEEKLY'].includes(frequency) || interval !== 1
+    || [...fields.keys()].some(key => !['FREQ', 'INTERVAL', 'BYHOUR', 'BYMINUTE', 'BYDAY'].includes(key))) return undefined;
+  const hourText = fields.get('BYHOUR') ?? '', minuteText = fields.get('BYMINUTE') ?? '';
+  if (!/^\d{1,2}$/.test(hourText) || Number(hourText) > 23 || !/^\d{1,2}$/.test(minuteText) || Number(minuteText) > 59) return undefined;
+  const dayValues = fields.has('BYDAY') ? fields.get('BYDAY')!.split(',') : [], days = new Set(dayValues);
+  if (frequency === 'DAILY' && fields.has('BYDAY')) return undefined;
+  if (frequency === 'WEEKLY' && (days.size === 0 || days.size !== dayValues.length
+    || [...days].some(day => !['MO', 'TU', 'WE', 'TH', 'FR', 'SA', 'SU'].includes(day)))) return undefined;
+  return { frequency, interval, hour: Number(hourText), minute: Number(minuteText), days };
+}
+
+export function validateScheduleRule(rule: string): boolean { return parse(rule) !== undefined; }
+
+/** One next native timestamp, not a scheduler. Civil dates keep daily/weekly times through DST. */
+export function nextNativeOccurrence(rule: string, now: number): number {
+  const schedule = parse(rule);
+  if (!schedule) throw Error('Choose a supported schedule.');
+  const current = new Date(now);
+  if (!Number.isFinite(current.getTime())) throw Error('The computer clock is unavailable.');
+  if (['MINUTELY', 'HOURLY'].includes(schedule.frequency)) {
+    return now + (schedule.frequency === 'MINUTELY' ? 60_000 : 3_600_000) * schedule.interval;
+  }
+  for (let offset = 0; offset <= 7; offset++) {
+    const candidate = new Date(current.getFullYear(), current.getMonth(), current.getDate() + offset, schedule.hour, schedule.minute);
+    const day = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'][candidate.getDay()]!;
+    if (candidate.getTime() > now && (schedule.days.size === 0 || schedule.days.has(day))) return candidate.getTime();
+  }
+  throw Error('This schedule has no future occurrence.');
+}

package/apps/bridge/src/task-schedules/changes.ts

@@ -0,0 +1,76 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { closeSync, fsyncSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { stringify } from 'smol-toml';
+import { TaskSchedulePatch } from '../../../../packages/protocol/task-schedules';
+import type { ScheduleRepositoryOptions, StoredSchedule } from '.';
+import { changeNativeSchedule } from './native-change';
+import { validateScheduleRule } from './cadence';
+
+function privateCheckpoint(path: string, bytes: string): void {
+  let descriptor: number | undefined;
+  try {
+    descriptor = openSync(path, 'wx', 0o600);
+    writeFileSync(descriptor, bytes); fsyncSync(descriptor);
+  }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'EEXIST' || readFileSync(path, 'utf8') !== bytes) throw error;
+  }
+  finally { if (descriptor !== undefined) closeSync(descriptor); }
+}
+
+function retainRecentCheckpoints(root: string, id: string, retained: string[]): void {
+  try {
+    const pattern = new RegExp('^' + id + '-[a-f0-9]{64}-(before|proposed-[a-f0-9]{64})\\.toml$');
+    const paths = readdirSync(root).filter(name => pattern.test(name)).map(name => join(root, name))
+      .filter(path => lstatSync(path).isFile()).sort((a, b) => lstatSync(b).mtimeMs - lstatSync(a).mtimeMs);
+    for (const path of paths.slice(20)) if (!retained.includes(path)) rmSync(path);
+  } catch { /* Retention cannot turn a successful native save into a failed edit. */ }
+}
+
+/** Both the old and proposed configuration survive a failed or concurrent write. */
+export function changeStoredSchedule(stored: StoredSchedule, revision: string, input: TaskSchedulePatch,
+  options: ScheduleRepositoryOptions): void {
+  if (stored.schedule.revision !== revision) throw Error('This automation changed. Refresh before editing it.');
+  if (!stored.schedule.editable) throw Error(stored.schedule.reason ?? 'This automation is read-only.');
+  const patch = TaskSchedulePatch.parse(input);
+  const needsRule = patch.rrule != null || patch.status === 'ACTIVE' && stored.schedule.status !== 'ACTIVE';
+  if (needsRule && !validateScheduleRule(patch.rrule ?? stored.schedule.rrule)) throw Error('Choose a supported schedule.');
+  const now = options.now?.() ?? Date.now();
+  if (!Number.isSafeInteger(now) || now < 0) throw Error('The computer clock is unavailable.');
+  const record = { ...stored.record, ...patch, updated_at: Math.max(now, Number(stored.record.updated_at ?? 0) + 1) };
+  const proposed = stringify(record);
+  if (Buffer.byteLength(proposed) > 65_536) throw Error('The automation exceeds its native file size limit.');
+  mkdirSync(options.backupRoot, { recursive: true, mode: 0o700 });
+  const base = stored.schedule.id + '-' + revision;
+  const before = join(options.backupRoot, base + '-before.toml');
+  const after = join(options.backupRoot, base + '-proposed-' + createHash('sha256').update(proposed).digest('hex') + '.toml');
+  privateCheckpoint(before, stored.text);
+  privateCheckpoint(after, proposed);
+  options.beforeCommit?.();
+  changeNativeSchedule(stored, record, { root: options.root, now, writeMirror: () => {
+    const latest = lstatSync(stored.path);
+    if (latest.isSymbolicLink() || !latest.isFile() || latest.size > 65_536
+      || createHash('sha256').update(readFileSync(stored.path)).digest('hex') !== revision) {
+      throw Error('This automation changed. Refresh before editing it.');
+    }
+    replaceFile(stored.path, proposed);
+  }, restoreMirror: () => {
+    if (readFileSync(stored.path, 'utf8') === proposed) replaceFile(stored.path, stored.text);
+  } });
+  retainRecentCheckpoints(options.backupRoot, stored.schedule.id, [before, after]);
+}
+
+function replaceFile(path: string, text: string): void {
+  const temporary = join(dirname(path), '.granttap-schedule-' + randomUUID());
+  let descriptor: number | undefined;
+  try {
+    descriptor = openSync(temporary, 'wx', 0o600);
+    writeFileSync(descriptor, text); fsyncSync(descriptor);
+    closeSync(descriptor); descriptor = undefined;
+    renameSync(temporary, path);
+  } finally {
+    if (descriptor !== undefined) closeSync(descriptor);
+    rmSync(temporary, { force: true });
+  }
+}

package/apps/bridge/src/task-schedules/controls.ts

@@ -0,0 +1,63 @@
+import { createHash } from 'node:crypto';
+import { TaskSchedulesRequest, TaskSchedulesResult } from '../../../../packages/protocol/task-schedules';
+import type { createTaskScheduleRepository } from '.';
+
+type Repository = ReturnType<typeof createTaskScheduleRepository>;
+type Delivery = { fingerprint: string; result: TaskSchedulesResult; at: number };
+type Context = { controller: string; sessions: readonly string[]; send: (result: TaskSchedulesResult) => Promise<void> };
+
+/** Edits are addressed to an existing native automation and idempotent per paired controller. */
+export class TaskScheduleControls {
+  private readonly deliveries = new Map<string, Delivery>();
+  constructor(private readonly repository: Repository, private readonly now: () => number = Date.now) {}
+
+  async handle(input: TaskSchedulesRequest, context: Context): Promise<boolean> {
+    const parsed = TaskSchedulesRequest.safeParse(input);
+    if (!parsed.success || Math.abs(this.now() - parsed.data.createdAt) > 120_000) return false;
+    const request = parsed.data, at = this.now();
+    for (const [key, value] of this.deliveries) if (at - value.at > 120_000) this.deliveries.delete(key);
+    const key = JSON.stringify([context.controller, request.requestId]);
+    const fingerprint = createHash('sha256').update(JSON.stringify(request)).digest('hex');
+    const previous = this.deliveries.get(key);
+    if (previous) {
+      if (previous.fingerprint !== fingerprint) return false;
+      await context.send(previous.result); return true;
+    }
+    if (this.deliveries.size >= 128) {
+      await context.send({ ...this.base(request, at), phase: 'unavailable',
+        message: 'Too many automation requests. Wait briefly and refresh status.' });
+      return true;
+    }
+    const result = this.prepare(request, context.sessions, at);
+    this.deliveries.set(key, { fingerprint, result, at });
+    await context.send(result);
+    return true;
+  }
+
+  private prepare(request: TaskSchedulesRequest, sessions: readonly string[], at: number): TaskSchedulesResult {
+    const base = this.base(request, at);
+    if (sessions.length === 0) return { ...base, phase: 'unavailable',
+      message: 'Codex automations are unavailable for this chat on this computer.' };
+    try {
+      const change = request.change;
+      const updated = change ? this.repository.change(change.id, change.revision, change.patch, sessions) : undefined;
+      const list = this.repository.list(sessions);
+      const schedules = updated ? [updated, ...list.schedules.filter(row => row.id !== updated.id)] : [...list.schedules];
+      let truncated = list.truncated;
+      while (schedules.length > 32 || Buffer.byteLength(JSON.stringify(schedules)) > 60_000) { schedules.pop(); truncated = true; }
+      return TaskSchedulesResult.parse({ ...base, schedules, truncated,
+        phase: updated && updated.confirmation !== 'confirmed' ? 'waiting' : 'completed' });
+    } catch (error) {
+      // Parser and native-storage errors can contain private configuration. Return only owned messages.
+      const message = error instanceof Error && /^(This automation |Choose a supported schedule\.|The native scheduler is unavailable\.|The computer clock is unavailable\.)/.test(error.message)
+        ? error.message.slice(0, 240) : 'The computer could not apply this change. Refresh before retrying.';
+      return { ...base, phase: 'failed', message };
+    }
+  }
+
+  private base(request: TaskSchedulesRequest, at: number) {
+    return { type: 'task.schedules.result' as const, requestId: request.requestId,
+      sessionId: request.sessionId, schedules: [], truncated: false,
+      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone, createdAt: at };
+  }
+}

package/apps/bridge/src/task-schedules/index.ts

@@ -0,0 +1,64 @@
+import { createHash } from 'node:crypto';
+import { isUtf8 } from 'node:buffer';
+import { existsSync, lstatSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse, type TomlTable } from 'smol-toml';
+import { TaskSchedule, TaskSchedulePatch } from '../../../../packages/protocol/task-schedules';
+import { changeStoredSchedule } from './changes';
+import { nativeScheduleState } from './native-state';
+
+export type ScheduleRepositoryOptions = { root: string; backupRoot: string; now?: () => number; beforeCommit?: () => void };
+export type StoredSchedule = { path: string; text: string; record: TomlTable; schedule: TaskSchedule };
+const validId = (id: string) => /^[a-zA-Z0-9_-]{1,160}$/.test(id);
+
+/** Native Codex heartbeat records; no parallel scheduler or provider execution. */
+export function createTaskScheduleRepository(options: ScheduleRepositoryOptions) {
+  const directory = join(options.root, 'automations');
+  function read(id: string, sessions: readonly string[]): StoredSchedule | undefined {
+    if (!validId(id)) return undefined;
+    const folder = join(directory, id), path = join(folder, 'automation.toml');
+    try {
+      if (!lstatSync(directory).isDirectory() || lstatSync(directory).isSymbolicLink()
+        || !lstatSync(folder).isDirectory() || lstatSync(folder).isSymbolicLink()) return undefined;
+      const stat = lstatSync(path);
+      if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 65_536) return undefined;
+      const bytes = readFileSync(path);
+      if (!isUtf8(bytes)) return undefined;
+      const text = bytes.toString('utf8'), record = parse(text);
+      if (record.version !== 1 || record.id !== id || record.kind !== 'heartbeat'
+        || typeof record.target_thread_id !== 'string' || !sessions.includes(record.target_thread_id)
+        || !Number.isSafeInteger(record.created_at) || Number(record.created_at) < 0
+        || !Number.isSafeInteger(record.updated_at) || Number(record.updated_at) < 0) return undefined;
+      const parsed = TaskSchedule.safeParse({ id, sessionId: record.target_thread_id,
+        name: record.name, prompt: record.prompt, rrule: record.rrule, status: record.status === 'DISABLED' ? 'PAUSED' : record.status,
+        revision: createHash('sha256').update(text).digest('hex'), editable: true, confirmation: 'unavailable' });
+      if (!parsed.success) return undefined;
+      const schedule = { ...parsed.data, ...nativeScheduleState(options.root, parsed.data, record) };
+      return { path, text, record, schedule };
+    } catch { return undefined; }
+  }
+  return {
+    list(sessions: readonly string[]) {
+      if (!existsSync(directory)) return { schedules: [] as TaskSchedule[], truncated: false };
+      const names = readdirSync(directory).slice(0, 512);
+      const schedules: TaskSchedule[] = [];
+      let bytes = 0, truncated = names.length === 512;
+      for (const id of names) {
+        const item = read(id, sessions)?.schedule;
+        if (!item) continue;
+        const size = Buffer.byteLength(JSON.stringify(item));
+        if (schedules.length === 32 || bytes + size > 60_000) { truncated = true; break; }
+        schedules.push(item); bytes += size;
+      }
+      return { schedules, truncated };
+    },
+    change(id: string, revision: string, patch: TaskSchedulePatch, sessions: readonly string[]): TaskSchedule {
+      const stored = read(id, sessions);
+      if (!stored) throw Error('This automation is unavailable in this chat.');
+      changeStoredSchedule(stored, revision, patch, options);
+      const saved = read(id, sessions);
+      if (!saved) throw Error('The native automation changed after saving. Refresh its status.');
+      return saved.schedule;
+    },
+  };
+}

package/apps/bridge/src/task-schedules/native-change.ts

@@ -0,0 +1,43 @@
+import { DatabaseSync, type SQLOutputValue } from 'node:sqlite';
+import type { TomlTable } from 'smol-toml';
+import type { StoredSchedule } from '.';
+import { findNativeSchedule, sameNativeSchedule } from './native-state';
+import { nextNativeOccurrence } from './cadence';
+
+function nativeTimestamp(value: SQLOutputValue | undefined): number | null {
+  if (value === null) return null;
+  if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0) return value;
+  throw Error('The native scheduler is unavailable.');
+}
+
+/** Commit the native scheduling state and its mirror together; never start a provider run. */
+export function changeNativeSchedule(stored: StoredSchedule, record: TomlTable,
+  commit: { root: string; now: number; writeMirror: () => void; restoreMirror: () => void }): void {
+  const store = findNativeSchedule(commit.root, stored.schedule.id);
+  if (!store) throw Error('The native scheduler is unavailable.');
+  const database = new DatabaseSync(store.path);
+  let fileChanged = false;
+  try {
+    database.exec('PRAGMA foreign_keys=ON; PRAGMA busy_timeout=250; BEGIN IMMEDIATE;');
+    const row = database.prepare('SELECT * FROM automations WHERE id=?').get(stored.schedule.id);
+    if (!row || !sameNativeSchedule(row, stored.schedule, stored.record)) throw Error('This automation changed. Refresh before editing.');
+    const reschedule = record.status === 'ACTIVE'
+      && (row.status !== 'ACTIVE' || row.rrule !== record.rrule);
+    const next = record.status === 'PAUSED' ? null : reschedule
+      ? nextNativeOccurrence(String(record.rrule), commit.now) : nativeTimestamp(row.next_run_at);
+    const nominal = record.status === 'PAUSED' ? null : reschedule ? next : nativeTimestamp(row.next_run_nominal_at);
+    const result = database.prepare(`UPDATE automations SET name=?,prompt=?,status=?,rrule=?,updated_at=?,
+      next_run_at=?,next_run_nominal_at=? WHERE id=? AND updated_at=? AND target_thread_id=?
+      AND kind='heartbeat' AND account_id IS NULL AND user_id IS NULL AND installation_id IS NULL`)
+      .run(String(record.name), String(record.prompt), String(record.status), String(record.rrule),
+        Number(record.updated_at), next, nominal, stored.schedule.id,
+        Number(stored.record.updated_at), stored.schedule.sessionId);
+    if (result.changes !== 1) throw Error('This automation changed. Refresh before editing.');
+    commit.writeMirror(); fileChanged = true;
+    database.exec('COMMIT;');
+  } catch (error) {
+    try { database.exec('ROLLBACK;'); } catch { /* No open transaction after a failed BEGIN. */ }
+    if (fileChanged) commit.restoreMirror();
+    throw error;
+  } finally { database.close(); }
+}

package/apps/bridge/src/task-schedules/native-state.ts

@@ -0,0 +1,63 @@
+import { existsSync, lstatSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { DatabaseSync, type SQLOutputValue } from 'node:sqlite';
+import type { TaskSchedule } from '../../../../packages/protocol/task-schedules';
+import type { TomlTable } from 'smol-toml';
+
+export type NativeScheduleRow = Record<string, SQLOutputValue>;
+export type NativeScheduleStore = { path: string; row: NativeScheduleRow };
+const columns = `id,name,prompt,status,rrule,updated_at,target_thread_id,kind,
+  account_id,user_id,installation_id,next_run_at,next_run_nominal_at`;
+
+function localScheduler(root: string): boolean {
+  const path = join(root, '.codex-global-state.json');
+  if (!existsSync(path)) return true;
+  try {
+    const stat = lstatSync(path);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 4 * 1024 * 1024) return false;
+    const state = JSON.parse(readFileSync(path, 'utf8'));
+    const migration = state?.['electron-persisted-atom-state']?.['electron-automations-habitat-migration-state'];
+    return migration === undefined || migration != null && typeof migration === 'object'
+      && !Array.isArray(migration) && Object.keys(migration).length === 0;
+  } catch { return false; }
+}
+
+/** Only a single, local native record can be controlled. Cloud ownership is never inferred. */
+export function findNativeSchedule(root: string, id: string): NativeScheduleStore | undefined {
+  if (!localScheduler(root)) return undefined;
+  const matches: NativeScheduleStore[] = [];
+  for (const name of ['codex-dev.db', 'codex.db']) {
+    const path = join(root, 'sqlite', name);
+    let database: DatabaseSync | undefined;
+    try {
+      if (![root, join(root, 'sqlite')].every(item => lstatSync(item).isDirectory()
+        && !lstatSync(item).isSymbolicLink())) continue;
+      if (!existsSync(path) || !lstatSync(path).isFile() || lstatSync(path).isSymbolicLink()) continue;
+      database = new DatabaseSync(path, { readOnly: true });
+      database.exec('PRAGMA query_only=ON; PRAGMA busy_timeout=50;');
+      const rows = database.prepare(`SELECT ${columns} FROM automations WHERE id=? OR legacy_automation_id=? LIMIT 2`).all(id, id);
+      for (const row of rows) matches.push({ path, row });
+    } catch { /* Locked, unsupported or incomplete stores remain read-only. */ }
+    finally { database?.close(); }
+  }
+  return matches.length === 1 ? matches[0] : undefined;
+}
+
+export function sameNativeSchedule(row: NativeScheduleRow, schedule: TaskSchedule, record: TomlTable): boolean {
+  return row.id === schedule.id && row.kind === 'heartbeat' && row.account_id == null
+    && row.user_id == null && row.installation_id == null && row.name === schedule.name
+    && row.prompt === schedule.prompt && row.status === schedule.status && row.rrule === schedule.rrule
+    && row.target_thread_id === schedule.sessionId && row.updated_at === record.updated_at;
+}
+
+export function nativeScheduleState(root: string, schedule: TaskSchedule, record: TomlTable): Pick<TaskSchedule, 'editable' | 'confirmation' | 'reason'> {
+  const store = findNativeSchedule(root, schedule.id);
+  if (!store) return { editable: false, confirmation: 'unavailable', reason: 'The native scheduler is unavailable or has an unsupported storage version.' };
+  if (store.row.account_id != null || store.row.user_id != null || store.row.installation_id != null) {
+    return { editable: false, confirmation: 'unavailable', reason: 'This automation is managed by the Codex account.' };
+  }
+  if (!sameNativeSchedule(store.row, schedule, record)) {
+    return { editable: false, confirmation: 'waiting', reason: 'The native automation changed. Refresh it in Codex before editing.' };
+  }
+  return { editable: true, confirmation: 'confirmed' };
+}

package/apps/bridge/src/task-schedules/relay.ts

@@ -0,0 +1,41 @@
+import { homedir } from 'node:os';
+import { isAbsolute, join } from 'node:path';
+import type { RelayClient } from '../../../../packages/core/relay-client';
+import { TaskSchedulesRequest } from '../../../../packages/protocol/task-schedules';
+import { configDir, loadConfig, machineConfigPath } from '../config';
+import { publishedCatalog, publishedSession } from '../session-catalog';
+import { sendSessionPayload } from '../host/session-keys';
+import { createTaskScheduleRepository } from '.';
+import { TaskScheduleControls } from './controls';
+
+let current: { root: string; controls: TaskScheduleControls } | undefined;
+
+/** Task scope comes from admitted executions. Native paths and peer identity are never phone supplied. */
+export async function handleTaskSchedules(client: RelayClient, input: TaskSchedulesRequest,
+  peer: string | undefined): Promise<boolean> {
+  const parsed = TaskSchedulesRequest.safeParse(input);
+  if (!peer || !parsed.success || Math.abs(Date.now() - parsed.data.createdAt) > 120_000) return false;
+  const request = parsed.data;
+  try {
+    const machine = loadConfig(machineConfigPath());
+    if (machine.role !== 'machine' || machine.room !== client.room
+      || machine.peerPublicKey !== peer && !machine.extraPeerPublicKeys?.includes(peer)) return false;
+  } catch { return false; }
+  const session = publishedSession(client, request.sessionId);
+  if (!session) return false;
+  const catalog = publishedCatalog(client);
+  const candidates = [...(catalog?.sessions ?? []), ...(catalog?.history ?? [])];
+  const sessions = [...new Set(candidates.filter(item => item.agent === 'codex'
+    && (item.sessionId === session.sessionId || session.projectId != null && session.taskId != null
+      && item.projectId === session.projectId && item.taskId === session.taskId)).map(item => item.sessionId))];
+  const root = process.env.GRANTTAP_CODEX_DIR ?? process.env.NODVOX_CODEX_DIR ?? process.env.CODEX_HOME ?? join(homedir(), '.codex');
+  if (!isAbsolute(root)) return false;
+  if (current?.root !== root) current = { root, controls: new TaskScheduleControls(createTaskScheduleRepository({
+    root, backupRoot: join(configDir(), 'task-schedule-checkpoints'),
+  })) };
+  return current.controls.handle(request, { controller: JSON.stringify([client.room, peer]), sessions,
+    send: result => sendSessionPayload(client, result, request.sessionId, 'phone', {
+      peerPublicKey: peer, reliable: false, urgent: true, ttlMs: 30_000,
+    }),
+  });
+}

package/cursor-plugin/README.md

@@ -10,7 +10,7 @@ keeps each phone response tied to the exact originating chat and prompt.
 Install the supported CLI on this computer, then run:
 
 ```bash
-npm install -g granttap-mcp@0.8.115
+npm install -g granttap-mcp@0.8.116
 granttap setup
 granttap status
 ```

package/cursor-plugin/mcp.json

@@ -4,7 +4,7 @@
       "command": "node",
       "args": [
         "-e",
-        "\"use strict\";\n\n// Cursor may start this MCP from any cwd. Execute JavaScript entry points with\n// Node itself: Windows batch shims require shell quoting that differs by host.\nconst { spawn } = require(\"node:child_process\");\nconst { existsSync } = require(\"node:fs\");\nconst { delimiter, dirname, join } = require(\"node:path\");\n\nconst PACKAGE = \"granttap-mcp@0.8.115\";\nconst dryRun = process.env.GRANTTAP_BOOTSTRAP_DRY_RUN === \"1\";\nconst platform = dryRun && process.env.GRANTTAP_BOOTSTRAP_PLATFORM\n  ? process.env.GRANTTAP_BOOTSTRAP_PLATFORM : process.platform;\nconst nodeRoot = dryRun && process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT\n  ? process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT : dirname(process.execPath);\nconst pathRoots = (process.env.PATH || \"\").split(delimiter).filter(Boolean);\nconst appData = process.env.APPDATA;\nconst roots = [nodeRoot, ...pathRoots, ...(appData ? [join(appData, \"npm\")] : [])];\nconst first = (paths) => paths.find((path) => existsSync(path));\n\nfunction launch() {\n  if (platform !== \"win32\") {\n    const installed = first(roots.map((root) => join(root, \"granttap-mcp\")));\n    if (installed) return { command: installed, args: [] };\n    const npx = first(roots.map((root) => join(root, \"npx\"))) || \"npx\";\n    return { command: npx, args: [\"-y\", PACKAGE] };\n  }\n  const installed = first(roots.map((root) =>\n    join(root, \"node_modules\", \"granttap-mcp\", \"bin\", \"granttap-mcp.mjs\")));\n  if (installed) return { command: process.execPath, args: [installed] };\n  const npx = first(roots.map((root) =>\n    join(root, \"node_modules\", \"npm\", \"bin\", \"npx-cli.js\")));\n  if (npx) return { command: process.execPath, args: [npx, \"-y\", PACKAGE] };\n  throw new Error(\"Node.js/npm 22.13.0+ is required on this Windows device. Install npm and retry GrantTap.\");\n}\n\nlet target;\ntry { target = launch(); }\ncatch (error) {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n}\n\nif (dryRun) {\n  process.stdout.write(JSON.stringify(target));\n  process.exit(0);\n}\n\nconst child = spawn(target.command, target.args, { stdio: \"inherit\", windowsHide: true });\nchild.on(\"error\", (error) => {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n});\nchild.on(\"exit\", (code, signal) => {\n  if (signal && platform !== \"win32\") {\n    try { process.kill(process.pid, signal); } catch { process.exit(code ?? 1); }\n    return;\n  }\n  process.exit(code ?? 1);\n});\n"
+        "\"use strict\";\n\n// Cursor may start this MCP from any cwd. Execute JavaScript entry points with\n// Node itself: Windows batch shims require shell quoting that differs by host.\nconst { spawn } = require(\"node:child_process\");\nconst { existsSync } = require(\"node:fs\");\nconst { delimiter, dirname, join } = require(\"node:path\");\n\nconst PACKAGE = \"granttap-mcp@0.8.116\";\nconst dryRun = process.env.GRANTTAP_BOOTSTRAP_DRY_RUN === \"1\";\nconst platform = dryRun && process.env.GRANTTAP_BOOTSTRAP_PLATFORM\n  ? process.env.GRANTTAP_BOOTSTRAP_PLATFORM : process.platform;\nconst nodeRoot = dryRun && process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT\n  ? process.env.GRANTTAP_BOOTSTRAP_NODE_ROOT : dirname(process.execPath);\nconst pathRoots = (process.env.PATH || \"\").split(delimiter).filter(Boolean);\nconst appData = process.env.APPDATA;\nconst roots = [nodeRoot, ...pathRoots, ...(appData ? [join(appData, \"npm\")] : [])];\nconst first = (paths) => paths.find((path) => existsSync(path));\n\nfunction launch() {\n  if (platform !== \"win32\") {\n    const installed = first(roots.map((root) => join(root, \"granttap-mcp\")));\n    if (installed) return { command: installed, args: [] };\n    const npx = first(roots.map((root) => join(root, \"npx\"))) || \"npx\";\n    return { command: npx, args: [\"-y\", PACKAGE] };\n  }\n  const installed = first(roots.map((root) =>\n    join(root, \"node_modules\", \"granttap-mcp\", \"bin\", \"granttap-mcp.mjs\")));\n  if (installed) return { command: process.execPath, args: [installed] };\n  const npx = first(roots.map((root) =>\n    join(root, \"node_modules\", \"npm\", \"bin\", \"npx-cli.js\")));\n  if (npx) return { command: process.execPath, args: [npx, \"-y\", PACKAGE] };\n  throw new Error(\"Node.js/npm 22.13.0+ is required on this Windows device. Install npm and retry GrantTap.\");\n}\n\nlet target;\ntry { target = launch(); }\ncatch (error) {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n}\n\nif (dryRun) {\n  process.stdout.write(JSON.stringify(target));\n  process.exit(0);\n}\n\nconst child = spawn(target.command, target.args, { stdio: \"inherit\", windowsHide: true });\nchild.on(\"error\", (error) => {\n  process.stderr.write(`[granttap] ${error.message}\\n`);\n  process.exit(1);\n});\nchild.on(\"exit\", (code, signal) => {\n  if (signal && platform !== \"win32\") {\n    try { process.kill(process.pid, signal); } catch { process.exit(code ?? 1); }\n    return;\n  }\n  process.exit(code ?? 1);\n});\n"
       ]
     }
   }

package/cursor-plugin/stdio-bootstrap.cjs

@@ -7,7 +7,7 @@ const { spawn } = require("node:child_process");
 const { existsSync } = require("node:fs");
 const { delimiter, dirname, join } = require("node:path");
 
-const PACKAGE = "granttap-mcp@0.8.115";
+const PACKAGE = "granttap-mcp@0.8.116";
 const dryRun = process.env.GRANTTAP_BOOTSTRAP_DRY_RUN === "1";
 const platform = dryRun && process.env.GRANTTAP_BOOTSTRAP_PLATFORM
   ? process.env.GRANTTAP_BOOTSTRAP_PLATFORM : process.platform;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "granttap-mcp",
-  "version": "0.8.115",
+  "version": "0.8.116",
   "description": "Commercial computer runtime connecting local coding agents to GrantTap on Mac, iPhone, iPad and Apple Watch.",
   "type": "module",
   "bin": {
@@ -39,6 +39,7 @@
     "@modelcontextprotocol/sdk": "^1.32.1",
     "express": "^5.2.1",
     "qrcode": "^1.5.4",
+    "smol-toml": "1.9.1",
     "tsx": "^4.23.4",
     "tweetnacl": "^1.0.3",
     "ws": "^8.18.0",

package/packages/protocol/schema.ts

@@ -2,6 +2,8 @@
 import { z } from "zod";
 import { DeviceManagementRequest, DeviceManagementResult } from './messages/device/management';
 export * from './messages/device/management';
+import { TaskSchedulesRequest, TaskSchedulesResult } from './task-schedules';
+export * from './task-schedules';
 import { ProjectTransportSet, ProjectTransportAck } from './task-network';
 export * from './task-network';
 import { TaskTransferContinue, TaskTransferContinueResult } from "./task-transfer";
@@ -117,6 +119,7 @@ export const MachineHeartbeat = z.object({
   machine: z.string().catch("machine"),
   createdAt: z.number().catch(() => Date.now()),
   taskQueueImmediate: z.boolean().optional(),
+  taskScheduleControls: z.boolean().optional(),
 });
 export type MachineHeartbeat = z.infer<typeof MachineHeartbeat>;
 
@@ -124,6 +127,8 @@ export type MachineHeartbeat = z.infer<typeof MachineHeartbeat>;
 // ZodEffects rather than plain objects. A regular union preserves those checks
 // while keeping the same strict `type` discriminator on every member.
 export const Payload = z.union([
+  TaskSchedulesRequest,
+  TaskSchedulesResult,
   DeviceManagementRequest,
   DeviceManagementResult,
   ApprovalRequest,

package/packages/protocol/task-schedules/README.md

@@ -0,0 +1,8 @@
+# Task schedule protocol
+
+Public entry: `index.ts`. Strict encrypted messages query or change existing native
+automations for an admitted chat. Names, instructions, recurrence and enabled state
+are separate from provider execution, delivery queues and capability policy.
+Results distinguish an applied change, an unconfirmed native state and failure.
+
+License: first-party code is under the GrantTap Commercial Source License in the repository LICENSE.

package/packages/protocol/task-schedules/index.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+
+const identifier = z.string().min(1).max(256);
+export const TaskSchedulePatch = z.object({
+  name: z.string().trim().min(1).max(160).optional(),
+  prompt: z.string().min(1).max(8192).refine(value => value.trim().length > 0).optional(),
+  rrule: z.string().trim().min(1).max(1024).optional(),
+  status: z.enum(['ACTIVE', 'PAUSED']).optional(),
+}).strict().refine(value => Object.keys(value).length > 0, 'An edit must change a supported field');
+export type TaskSchedulePatch = z.infer<typeof TaskSchedulePatch>;
+export const TaskSchedule = z.object({
+  id: identifier, sessionId: identifier, name: z.string().min(1).max(160),
+  prompt: z.string().max(8192), rrule: z.string().max(1024),
+  status: z.enum(['ACTIVE', 'PAUSED']), revision: z.string().regex(/^[a-f0-9]{64}$/),
+  editable: z.boolean(), confirmation: z.enum(['confirmed', 'waiting', 'unavailable']),
+  reason: z.string().max(240).optional(),
+}).strict();
+export type TaskSchedule = z.infer<typeof TaskSchedule>;
+export const TaskSchedulesRequest = z.object({
+  type: z.literal('task.schedules'), requestId: identifier, sessionId: identifier,
+  createdAt: z.number().finite(),
+  change: z.object({ id: identifier, revision: z.string().regex(/^[a-f0-9]{64}$/), patch: TaskSchedulePatch }).strict().optional(),
+}).strict();
+export type TaskSchedulesRequest = z.infer<typeof TaskSchedulesRequest>;
+export const TaskSchedulesResult = z.object({
+  type: z.literal('task.schedules.result'), requestId: identifier, sessionId: identifier,
+  phase: z.enum(['completed', 'waiting', 'failed', 'unavailable']),
+  schedules: z.array(TaskSchedule).max(32), truncated: z.boolean(),
+  timeZone: z.string().max(100), message: z.string().max(240).optional(), createdAt: z.number().finite(),
+}).strict().refine(value => new Set(value.schedules.map(row => row.id)).size === value.schedules.length
+  && new TextEncoder().encode(JSON.stringify(value)).length <= 65_536);
+export type TaskSchedulesResult = z.infer<typeof TaskSchedulesResult>;