ticlawk 0.1.17-dev.5 → 0.1.17-dev.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticlawk",
-  "version": "0.1.17-dev.5",
+  "version": "0.1.17-dev.7",
   "description": "Local connector that links agent harnesses (Claude Code, Codex, OpenClaw, opencode, Pi) to the Ticlawk mobile app.",
   "type": "module",
   "main": "ticlawk.mjs",

package/src/adapters/ticlawk/api.mjs

@@ -375,7 +375,7 @@ export async function getAgentServerInfo({ actingAgentId }) {
 // ── Reminders ──
 
 export async function scheduleAgentReminder({
-  actingAgentId, title, fireAt, anchorConversationId, anchorMessageId,
+  actingAgentId, title, fireAt, anchorConversationId, anchorMessageId, recurrence,
 }) {
   return apiFetch('/api/agent/reminders', {
     method: 'POST',
@@ -385,6 +385,7 @@ export async function scheduleAgentReminder({
       fire_at: fireAt,
       anchor_conversation_id: anchorConversationId,
       anchor_message_id: anchorMessageId ?? null,
+      recurrence: recurrence ?? null,
     }),
   });
 }

package/src/cli/agent-commands.mjs

@@ -557,6 +557,18 @@ export async function runReminderScheduleCommand(args) {
     console.error('--target or --anchor-conversation-id is required');
     return 2;
   }
+  // Optional recurrence: --recur-at HH:MM [--recur-tz <IANA>] [--recur-weekday 1,2,3].
+  // --fire-at remains the FIRST occurrence; the rule advances it after each fire.
+  let recurrence = null;
+  const recurAt = getArg(args, 'recur-at');
+  if (recurAt) {
+    const tz = getArg(args, 'recur-tz') || 'UTC';
+    const wdRaw = getArg(args, 'recur-weekday');
+    const byWeekday = wdRaw
+      ? String(wdRaw).split(',').map((s) => parseInt(s.trim(), 10)).filter((n) => n >= 1 && n <= 7)
+      : [];
+    recurrence = { at: recurAt, tz, ...(byWeekday.length ? { by_weekday: byWeekday } : {}) };
+  }
   const res = await daemonRequest({
     method: 'POST',
     path: '/agent/reminder/schedule',
@@ -567,6 +579,7 @@ export async function runReminderScheduleCommand(args) {
       target,
       anchor_conversation_id: anchorConversationId,
       anchor_message_id: anchorMessageId,
+      recurrence,
     },
   });
   printJson(res.body);
@@ -1425,7 +1438,7 @@ export const AGENT_COMMAND_HELP = {
     to a user, use \`ticlawk message send --attach <file>\` instead.
 `,
   reminder: `ticlawk reminder <schedule|list|snooze|update|cancel|log>
-  ticlawk reminder schedule --title <t> (--fire-at <iso> | --in-seconds N | --in-minutes N) (--target "<target>" | --anchor-conversation-id <id>) [--anchor-message-id <id>]
+  ticlawk reminder schedule --title <t> (--fire-at <iso> | --in-seconds N | --in-minutes N) (--target "<target>" | --anchor-conversation-id <id>) [--anchor-message-id <id>] [--recur-at HH:MM [--recur-tz <IANA>] [--recur-weekday 1,2,3]]
   ticlawk reminder list [--status active|fired|canceled]
   ticlawk reminder snooze <reminder-id> (--fire-at <iso> | --in-seconds N | --in-minutes N)
   ticlawk reminder update <reminder-id> [--title <t>] [--fire-at <iso>]
@@ -1435,6 +1448,17 @@ export const AGENT_COMMAND_HELP = {
   Use reminders for follow-up that depends on future state you cannot resolve
   now. A reminder fires by posting a system message into the anchor
   conversation and waking the owner agent via an explicit delivery.
+
+  RECURRING: for a fixed cadence (e.g. a daily/weekly meal-time check-in), use
+  ONE recurring reminder instead of enumerating many one-shots. Pass --recur-at
+  (local HH:MM), --recur-tz (the owner's IANA timezone), and optionally
+  --recur-weekday (ISO 1=Mon..7=Sun, comma-separated; omit for every day).
+  --fire-at is still the FIRST occurrence; on each fire the reminder
+  auto-advances to the next occurrence and stays active. Example — weekday
+  18:30 Beijing dinner check-in:
+    ticlawk reminder schedule --title "晚餐" --anchor-conversation-id <id> \\
+      --fire-at <next 18:30 Beijing as ISO> \\
+      --recur-at 18:30 --recur-tz Asia/Shanghai --recur-weekday 1,2,3,4,5
 `,
   task: `ticlawk task <create|claim|unclaim|update|list>
   ticlawk task create --target "<target>" [--title <t>] [--assign-agent <agent-id>]

package/src/core/agent-cli-handlers.mjs

@@ -590,6 +590,7 @@ export async function handleReminderSchedule(req, body, ctx) {
       fireAt: body.fire_at,
       anchorConversationId,
       anchorMessageId: body?.anchor_message_id || null,
+      recurrence: body?.recurrence ?? null,
     });
     debugLog('agent-cli', 'reminder.schedule', {
       actingAgentId,

package/src/runtimes/_shared/goal-step-prompt.mjs

@@ -15,10 +15,10 @@ import { buildEnvelopeTarget, buildCharterBlock } from './wake-prompt.mjs';
 const STEP_GUIDES = {
   gap_analysis: {
     title: 'GAP ANALYSIS',
-    body: `Compare the current state of the work against the goal and success criteria. Read whatever you need (charter, dashboard, task board, repo, prior messages) to judge where things actually stand. The dashboard is the owner's at-a-glance visualization of how far this goal has progressed — this step owns keeping it true to reality: if a durable goal has no dashboard yet, create it (\`ticlawk dashboard set\`); if overall progress has moved materially, refresh its content/data. See SURFACES.md.
-- If there is concrete executable work toward the goal, first make sure the next unit exists as a task (create/assign it with \`ticlawk task ...\` when a task fits), then report outcome=gap.
-- If the goal/milestone is fully met with no meaningful gap, make sure the dashboard reflects the completed state, then report outcome=no_gap. (The completed result is something the owner is waiting on — surface it per the briefing rule below.)
-- If closing the gap depends on a future or external state that nobody can act on right now, schedule a reminder for the resume condition, then report outcome=wait.`,
+    body: `Compare the current state against the goal and success criteria. The [goal_context] block above gives you the open tasks, active reminders, and dashboard state — judge from it; read the charter/repo/prior messages only for what it doesn't cover. The dashboard is the owner's at-a-glance visualization of how far this goal has progressed — this step owns keeping it true to reality: create it if a durable goal has none, refresh it when progress moved materially (\`ticlawk dashboard set\`; see SURFACES.md).
+- If there is concrete work to do NOW, make sure the next unit exists as a task (\`ticlawk task ...\`), then report outcome=gap.
+- If nothing needs doing this instant but the goal is ONGOING/STANDING — its job is to keep something maintained and work recurs (e.g. an active recurring reminder above already covers the next occurrence) — report outcome=wait. Do NOT report no_gap for a standing goal: it has no "done", and parking on no_gap would stop it from waking at the next occurrence. If nothing is scheduled to resume it yet, schedule a reminder first, then report wait.
+- Report outcome=no_gap ONLY if the goal is genuinely, permanently met and will never need action again (an achievement goal that is finished). The completed result is something the owner is waiting on — surface it per the briefing rule below.`,
     outcomes: ['gap', 'no_gap', 'wait'],
   },
   execute: {
@@ -48,6 +48,31 @@ function readPayload(msg) {
   };
 }
 
+// Per-step context: the claim attaches msg.goal_context (open tasks, active
+// reminders, current task, dashboard) for transition deliveries. Render the
+// slice THIS step needs so each step decides on facts, not guesses.
+function buildGoalContextBlock(msg, step) {
+  const gc = msg && msg.goal_context && typeof msg.goal_context === 'object' ? msg.goal_context : null;
+  if (!gc) return '';
+  const lines = ['[goal_context] Current state for this goal (given to you — use it, do not re-derive):'];
+  if (step === 'gap_analysis' || !STEP_GUIDES[step]) {
+    const tasks = Array.isArray(gc.open_tasks) ? gc.open_tasks : [];
+    const rems = Array.isArray(gc.active_reminders) ? gc.active_reminders : [];
+    lines.push(`- open tasks (${tasks.length}): ${tasks.length
+      ? tasks.map((t) => `#${t.number} ${t.title} [${t.status}]`).join('; ')
+      : 'none'}`);
+    lines.push(`- active reminders (${rems.length}): ${rems.length
+      ? rems.map((r) => `"${r.title}" @ ${r.fire_at}${r.recurrence ? ' (recurring)' : ''}`).join('; ')
+      : 'none'}`);
+    lines.push(`- dashboard: ${gc.dashboard ? 'exists' : 'none yet'}`);
+  } else {
+    const ct = gc.current_task;
+    lines.push(ct ? `- current task: #${ct.number} ${ct.title} [${ct.status}]` : '- current task: (none set)');
+  }
+  lines.push('[/goal_context]');
+  return lines.join('\n');
+}
+
 function buildGoalStepHeader(msg, { step, transitionId, goalVersion, kind }) {
   const target = buildEnvelopeTarget(msg);
   const time = msg.created_at || new Date().toISOString();
@@ -66,6 +91,8 @@ export function buildGoalStepPrompt(msg) {
 
   const sections = [];
   if (charterBlock) sections.push(charterBlock);
+  const goalContextBlock = buildGoalContextBlock(msg, step);
+  if (goalContextBlock) sections.push(goalContextBlock);
 
   if (guide) {
     sections.push([

package/src/runtimes/_shared/handbook/SURFACES.md

@@ -39,3 +39,5 @@ Use `ticlawk credential request --name <ENV_VAR>` to create the credential slot.
 ## Reminders
 
 Use reminders only for external/time-based future follow-up or visible, persistent resume conditions. Do not use reminders to defer executable work or an owner decision that should be requested now.
+
+For a fixed cadence (a daily or weekly check-in, e.g. meal-time reminders), use ONE recurring reminder, not many enumerated one-shots: `ticlawk reminder schedule ... --recur-at HH:MM --recur-tz <owner IANA tz> [--recur-weekday 1,2,3]`. It auto-advances to the next occurrence on each fire and stays active, so the cadence never runs out.