@xortex/xcode 3.0.0

package/tools/ScheduleCronTool/CronDeleteTool.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod/v4'
+import type { ValidationResult } from '../../Tool.js'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import {
+  getCronFilePath,
+  listAllCronTasks,
+  removeCronTasks,
+} from '../../utils/cronTasks.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { getTeammateContext } from '../../utils/teammateContext.js'
+import {
+  buildCronDeletePrompt,
+  CRON_DELETE_DESCRIPTION,
+  CRON_DELETE_TOOL_NAME,
+  isDurableCronEnabled,
+  isKairosCronEnabled,
+} from './prompt.js'
+import { renderDeleteResultMessage, renderDeleteToolUseMessage } from './UI.js'
+
+const inputSchema = lazySchema(() =>
+  z.strictObject({
+    id: z.string().describe('Job ID returned by CronCreate.'),
+  }),
+)
+type InputSchema = ReturnType<typeof inputSchema>
+
+const outputSchema = lazySchema(() =>
+  z.object({
+    id: z.string(),
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+export type DeleteOutput = z.infer<OutputSchema>
+
+export const CronDeleteTool = buildTool({
+  name: CRON_DELETE_TOOL_NAME,
+  searchHint: 'cancel a scheduled cron job',
+  maxResultSizeChars: 100_000,
+  shouldDefer: true,
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  isEnabled() {
+    return isKairosCronEnabled()
+  },
+  toAutoClassifierInput(input) {
+    return input.id
+  },
+  async description() {
+    return CRON_DELETE_DESCRIPTION
+  },
+  async prompt() {
+    return buildCronDeletePrompt(isDurableCronEnabled())
+  },
+  getPath() {
+    return getCronFilePath()
+  },
+  async validateInput(input): Promise<ValidationResult> {
+    const tasks = await listAllCronTasks()
+    const task = tasks.find(t => t.id === input.id)
+    if (!task) {
+      return {
+        result: false,
+        message: `No scheduled job with id '${input.id}'`,
+        errorCode: 1,
+      }
+    }
+    // Teammates may only delete their own crons.
+    const ctx = getTeammateContext()
+    if (ctx && task.agentId !== ctx.agentId) {
+      return {
+        result: false,
+        message: `Cannot delete cron job '${input.id}': owned by another agent`,
+        errorCode: 2,
+      }
+    }
+    return { result: true }
+  },
+  async call({ id }) {
+    await removeCronTasks([id])
+    return { data: { id } }
+  },
+  mapToolResultToToolResultBlockParam(output, toolUseID) {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content: `Cancelled job ${output.id}.`,
+    }
+  },
+  renderToolUseMessage: renderDeleteToolUseMessage,
+  renderToolResultMessage: renderDeleteResultMessage,
+} satisfies ToolDef<InputSchema, DeleteOutput>)

package/tools/ScheduleCronTool/CronListTool.ts

@@ -0,0 +1,97 @@
+import { z } from 'zod/v4'
+import { buildTool, type ToolDef } from '../../Tool.js'
+import { cronToHuman } from '../../utils/cron.js'
+import { listAllCronTasks } from '../../utils/cronTasks.js'
+import { truncate } from '../../utils/format.js'
+import { lazySchema } from '../../utils/lazySchema.js'
+import { getTeammateContext } from '../../utils/teammateContext.js'
+import {
+  buildCronListPrompt,
+  CRON_LIST_DESCRIPTION,
+  CRON_LIST_TOOL_NAME,
+  isDurableCronEnabled,
+  isKairosCronEnabled,
+} from './prompt.js'
+import { renderListResultMessage, renderListToolUseMessage } from './UI.js'
+
+const inputSchema = lazySchema(() => z.strictObject({}))
+type InputSchema = ReturnType<typeof inputSchema>
+
+const outputSchema = lazySchema(() =>
+  z.object({
+    jobs: z.array(
+      z.object({
+        id: z.string(),
+        cron: z.string(),
+        humanSchedule: z.string(),
+        prompt: z.string(),
+        recurring: z.boolean().optional(),
+        durable: z.boolean().optional(),
+      }),
+    ),
+  }),
+)
+type OutputSchema = ReturnType<typeof outputSchema>
+export type ListOutput = z.infer<OutputSchema>
+
+export const CronListTool = buildTool({
+  name: CRON_LIST_TOOL_NAME,
+  searchHint: 'list active cron jobs',
+  maxResultSizeChars: 100_000,
+  shouldDefer: true,
+  get inputSchema(): InputSchema {
+    return inputSchema()
+  },
+  get outputSchema(): OutputSchema {
+    return outputSchema()
+  },
+  isEnabled() {
+    return isKairosCronEnabled()
+  },
+  isConcurrencySafe() {
+    return true
+  },
+  isReadOnly() {
+    return true
+  },
+  async description() {
+    return CRON_LIST_DESCRIPTION
+  },
+  async prompt() {
+    return buildCronListPrompt(isDurableCronEnabled())
+  },
+  async call() {
+    const allTasks = await listAllCronTasks()
+    // Teammates only see their own crons; team lead (no ctx) sees all.
+    const ctx = getTeammateContext()
+    const tasks = ctx
+      ? allTasks.filter(t => t.agentId === ctx.agentId)
+      : allTasks
+    const jobs = tasks.map(t => ({
+      id: t.id,
+      cron: t.cron,
+      humanSchedule: cronToHuman(t.cron),
+      prompt: t.prompt,
+      ...(t.recurring ? { recurring: true } : {}),
+      ...(t.durable === false ? { durable: false } : {}),
+    }))
+    return { data: { jobs } }
+  },
+  mapToolResultToToolResultBlockParam(output, toolUseID) {
+    return {
+      tool_use_id: toolUseID,
+      type: 'tool_result',
+      content:
+        output.jobs.length > 0
+          ? output.jobs
+              .map(
+                j =>
+                  `${j.id} — ${j.humanSchedule}${j.recurring ? ' (recurring)' : ' (one-shot)'}${j.durable === false ? ' [session-only]' : ''}: ${truncate(j.prompt, 80, true)}`,
+              )
+              .join('\n')
+          : 'No scheduled jobs.',
+    }
+  },
+  renderToolUseMessage: renderListToolUseMessage,
+  renderToolResultMessage: renderListResultMessage,
+} satisfies ToolDef<InputSchema, ListOutput>)

package/tools/ScheduleCronTool/UI.tsx

@@ -0,0 +1,60 @@
+import React from 'react';
+import { MessageResponse } from '../../components/MessageResponse.js';
+import { Text } from '../../ink.js';
+import { truncate } from '../../utils/format.js';
+import type { CreateOutput } from './CronCreateTool.js';
+import type { DeleteOutput } from './CronDeleteTool.js';
+import type { ListOutput } from './CronListTool.js';
+
+// --- CronCreate -------------------------------------------------------------
+
+export function renderCreateToolUseMessage(input: Partial<{
+  cron: string;
+  prompt: string;
+}>): React.ReactNode {
+  return `${input.cron ?? ''}${input.prompt ? `: ${truncate(input.prompt, 60, true)}` : ''}`;
+}
+export function renderCreateResultMessage(output: CreateOutput): React.ReactNode {
+  return <MessageResponse>
+      <Text>
+        Scheduled <Text bold>{output.id}</Text>{' '}
+        <Text dimColor>({output.humanSchedule})</Text>
+      </Text>
+    </MessageResponse>;
+}
+
+// --- CronDelete -------------------------------------------------------------
+
+export function renderDeleteToolUseMessage(input: Partial<{
+  id: string;
+}>): React.ReactNode {
+  return input.id ?? '';
+}
+export function renderDeleteResultMessage(output: DeleteOutput): React.ReactNode {
+  return <MessageResponse>
+      <Text>
+        Cancelled <Text bold>{output.id}</Text>
+      </Text>
+    </MessageResponse>;
+}
+
+// --- CronList ---------------------------------------------------------------
+
+export function renderListToolUseMessage(): React.ReactNode {
+  return '';
+}
+export function renderListResultMessage(output: ListOutput): React.ReactNode {
+  if (output.jobs.length === 0) {
+    return <MessageResponse>
+        <Text dimColor>No scheduled jobs</Text>
+      </MessageResponse>;
+  }
+  return <MessageResponse>
+      {output.jobs.map(j => <Text key={j.id}>
+          <Text bold>{j.id}</Text> <Text dimColor>{j.humanSchedule}</Text>
+        </Text>)}
+    </MessageResponse>;
+}
+
+// --- Shared -----------------------------------------------------------------
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/tools/ScheduleCronTool/prompt.ts

@@ -0,0 +1,135 @@
+import { feature } from 'bun:bundle'
+import { getFeatureValue_CACHED_WITH_REFRESH } from '../../services/analytics/growthbook.js'
+import { DEFAULT_CRON_JITTER_CONFIG } from '../../utils/cronTasks.js'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+
+const KAIROS_CRON_REFRESH_MS = 5 * 60 * 1000
+
+export const DEFAULT_MAX_AGE_DAYS =
+  DEFAULT_CRON_JITTER_CONFIG.recurringMaxAgeMs / (24 * 60 * 60 * 1000)
+
+/**
+ * Unified gate for the cron scheduling system. Combines the build-time
+ * `feature('AGENT_TRIGGERS')` flag (dead code elimination) with the runtime
+ * `tengu_kairos_cron` GrowthBook gate on a 5-minute refresh window.
+ *
+ * AGENT_TRIGGERS is independently shippable from KAIROS — the cron module
+ * graph (cronScheduler/cronTasks/cronTasksLock/cron.ts + the three tools +
+ * /loop skill) has zero imports into src/assistant/ and no feature('KAIROS')
+ * calls. The REPL.tsx kairosEnabled read is safe:
+ * kairosEnabled is unconditionally in AppStateStore with default false, so
+ * when KAIROS is off the scheduler just gets assistantMode: false.
+ *
+ * Called from Tool.isEnabled() (lazy, post-init) and inside useEffect /
+ * imperative setup, never at module scope — so the disk cache has had a
+ * chance to populate.
+ *
+ * The default is `true` — /loop is GA (announced in changelog). GrowthBook
+ * is disabled for Bedrock/Vertex/Foundry and when DISABLE_TELEMETRY /
+ * CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC are set; a `false` default would
+ * break /loop for those users (GH #31759). The GB gate now serves purely as
+ * a fleet-wide kill switch — flipping it to `false` stops already-running
+ * schedulers on their next isKilled poll tick, not just new ones.
+ *
+ * `CLAUDE_CODE_DISABLE_CRON` is a local override that wins over GB.
+ */
+export function isKairosCronEnabled(): boolean {
+  return feature('AGENT_TRIGGERS')
+    ? !isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_CRON) &&
+        getFeatureValue_CACHED_WITH_REFRESH(
+          'tengu_kairos_cron',
+          true,
+          KAIROS_CRON_REFRESH_MS,
+        )
+    : false
+}
+
+/**
+ * Kill switch for disk-persistent (durable) cron tasks. Narrower than
+ * {@link isKairosCronEnabled} — flipping this off forces `durable: false` at
+ * the call() site, leaving session-only cron (in-memory, GA) untouched.
+ *
+ * Defaults to `true` so Bedrock/Vertex/Foundry and DISABLE_TELEMETRY users get
+ * durable cron. Does NOT consult CLAUDE_CODE_DISABLE_CRON (that kills the whole
+ * scheduler via isKairosCronEnabled).
+ */
+export function isDurableCronEnabled(): boolean {
+  return getFeatureValue_CACHED_WITH_REFRESH(
+    'tengu_kairos_cron_durable',
+    true,
+    KAIROS_CRON_REFRESH_MS,
+  )
+}
+
+export const CRON_CREATE_TOOL_NAME = 'CronCreate'
+export const CRON_DELETE_TOOL_NAME = 'CronDelete'
+export const CRON_LIST_TOOL_NAME = 'CronList'
+
+export function buildCronCreateDescription(durableEnabled: boolean): string {
+  return durableEnabled
+    ? 'Schedule a prompt to run at a future time — either recurring on a cron schedule, or once at a specific time. Pass durable: true to persist to .claude/scheduled_tasks.json; otherwise session-only.'
+    : 'Schedule a prompt to run at a future time within this Claude session — either recurring on a cron schedule, or once at a specific time.'
+}
+
+export function buildCronCreatePrompt(durableEnabled: boolean): string {
+  const durabilitySection = durableEnabled
+    ? `## Durability
+
+By default (durable: false) the job lives only in this Claude session — nothing is written to disk, and the job is gone when Claude exits. Pass durable: true to write to .claude/scheduled_tasks.json so the job survives restarts. Only use durable: true when the user explicitly asks for the task to persist ("keep doing this every day", "set this up permanently"). Most "remind me in 5 minutes" / "check back in an hour" requests should stay session-only.`
+    : `## Session-only
+
+Jobs live only in this Claude session — nothing is written to disk, and the job is gone when Claude exits.`
+
+  const durableRuntimeNote = durableEnabled
+    ? 'Durable jobs persist to .claude/scheduled_tasks.json and survive session restarts — on next launch they resume automatically. One-shot durable tasks that were missed while the REPL was closed are surfaced for catch-up. Session-only jobs die with the process. '
+    : ''
+
+  return `Schedule a prompt to be enqueued at a future time. Use for both recurring schedules and one-shot reminders.
+
+Uses standard 5-field cron in the user's local timezone: minute hour day-of-month month day-of-week. "0 9 * * *" means 9am local — no timezone conversion needed.
+
+## One-shot tasks (recurring: false)
+
+For "remind me at X" or "at <time>, do Y" requests — fire once then auto-delete.
+Pin minute/hour/day-of-month/month to specific values:
+  "remind me at 2:30pm today to check the deploy" → cron: "30 14 <today_dom> <today_month> *", recurring: false
+  "tomorrow morning, run the smoke test" → cron: "57 8 <tomorrow_dom> <tomorrow_month> *", recurring: false
+
+## Recurring jobs (recurring: true, the default)
+
+For "every N minutes" / "every hour" / "weekdays at 9am" requests:
+  "*/5 * * * *" (every 5 min), "0 * * * *" (hourly), "0 9 * * 1-5" (weekdays at 9am local)
+
+## Avoid the :00 and :30 minute marks when the task allows it
+
+Every user who asks for "9am" gets \`0 9\`, and every user who asks for "hourly" gets \`0 *\` — which means requests from across the planet land on the API at the same instant. When the user's request is approximate, pick a minute that is NOT 0 or 30:
+  "every morning around 9" → "57 8 * * *" or "3 9 * * *" (not "0 9 * * *")
+  "hourly" → "7 * * * *" (not "0 * * * *")
+  "in an hour or so, remind me to..." → pick whatever minute you land on, don't round
+
+Only use minute 0 or 30 when the user names that exact time and clearly means it ("at 9:00 sharp", "at half past", coordinating with a meeting). When in doubt, nudge a few minutes early or late — the user will not notice, and the fleet will.
+
+${durabilitySection}
+
+## Runtime behavior
+
+Jobs only fire while the REPL is idle (not mid-query). ${durableRuntimeNote}The scheduler adds a small deterministic jitter on top of whatever you pick: recurring tasks fire up to 10% of their period late (max 15 min); one-shot tasks landing on :00 or :30 fire up to 90 s early. Picking an off-minute is still the bigger lever.
+
+Recurring tasks auto-expire after ${DEFAULT_MAX_AGE_DAYS} days — they fire one final time, then are deleted. This bounds session lifetime. Tell the user about the ${DEFAULT_MAX_AGE_DAYS}-day limit when scheduling recurring jobs.
+
+Returns a job ID you can pass to ${CRON_DELETE_TOOL_NAME}.`
+}
+
+export const CRON_DELETE_DESCRIPTION = 'Cancel a scheduled cron job by ID'
+export function buildCronDeletePrompt(durableEnabled: boolean): string {
+  return durableEnabled
+    ? `Cancel a cron job previously scheduled with ${CRON_CREATE_TOOL_NAME}. Removes it from .claude/scheduled_tasks.json (durable jobs) or the in-memory session store (session-only jobs).`
+    : `Cancel a cron job previously scheduled with ${CRON_CREATE_TOOL_NAME}. Removes it from the in-memory session store.`
+}
+
+export const CRON_LIST_DESCRIPTION = 'List scheduled cron jobs'
+export function buildCronListPrompt(durableEnabled: boolean): string {
+  return durableEnabled
+    ? `List all cron jobs scheduled via ${CRON_CREATE_TOOL_NAME}, both durable (.claude/scheduled_tasks.json) and session-only.`
+    : `List all cron jobs scheduled via ${CRON_CREATE_TOOL_NAME} in this session.`
+}