@robbeverhelst/do 1.174.0 → 1.175.0

package/dist/do.js

@@ -3607,7 +3607,8 @@ var areas = pgTable("areas", {
   archivedAt: timestamp("archived_at", { withTimezone: true }),
   purpose: text("purpose"),
   standards: jsonb("standards").$type().notNull().default(sql`'[]'::jsonb`),
-  restingUntil: date("resting_until", { mode: "string" })
+  restingUntil: date("resting_until", { mode: "string" }),
+  lastReviewedAt: timestamp("last_reviewed_at", { withTimezone: true })
 }, (t) => [
   index("areas_tenant_idx").on(t.tenantId),
   check("areas_standards_chk", sql`jsonb_typeof(${t.standards}) = 'array' AND jsonb_array_length(${t.standards}) <= 5`)
@@ -3818,7 +3819,8 @@ var tasks = pgTable("tasks", {
   proposedDesk: text("proposed_desk"),
   notNowUntil: timestamp("not_now_until", { withTimezone: true }),
   readyAt: timestamp("ready_at", { withTimezone: true }),
-  readyNote: text("ready_note")
+  readyNote: text("ready_note"),
+  moveCount: integer("move_count").notNull().default(0)
 }, (t) => [
   index("tasks_tenant_project_idx").on(t.tenantId, t.projectId),
   index("tasks_tenant_place_idx").on(t.tenantId, t.placeId),
@@ -3917,7 +3919,8 @@ var notificationType = pgEnum("notification_type", [
   "streak_at_risk",
   "reflection_nudge",
   "shutdown_nudge",
-  "habit_reminder"
+  "habit_reminder",
+  "echo"
 ]);
 var notifications = pgTable("notifications", {
   id: text("id").primaryKey(),
@@ -18432,7 +18435,8 @@ var taskViewSchema = taskSchema.omit({
   source: true,
   completedByUserId: true,
   completedByAgentId: true,
-  filingSuggestion: true
+  filingSuggestion: true,
+  moveCount: true
 }).extend({
   title: string2(),
   parentId: ulidSchema.nullable(),
@@ -19221,21 +19225,28 @@ var areaStandardViewSchema = areaStandardSchema.extend({
 });
 var areaSchema = createSelectSchema(areas, {
   purpose: string2().nullable().default(null),
-  standards: array(areaStandardSchema).default([])
+  standards: array(areaStandardSchema).default([]),
+  lastReviewedAt: exports_coerce.date().nullable().default(null)
 });
 var areaIconSchema = string2().trim().min(1).max(64);
 var createAreaInputSchema = createInsertSchema(areas, {
   id: ulidSchema,
   icon: areaIconSchema.nullish(),
   purpose: areaPurposeSchema.nullish()
-}).omit({ tenantId: true, archivedAt: true, standards: true, restingUntil: true }).extend({ title: string2().min(1) });
+}).omit({
+  tenantId: true,
+  archivedAt: true,
+  standards: true,
+  restingUntil: true,
+  lastReviewedAt: true
+}).extend({ title: string2().min(1) });
 var updateAreaInputSchema = createUpdateSchema(areas, {
   icon: areaIconSchema.nullish(),
   archivedAt: exports_coerce.date().nullish(),
   purpose: areaPurposeSchema.nullish(),
   standards: array(areaStandardInputSchema).max(5).optional(),
   restingUntil: exports_iso.date().nullish()
-}).omit({ id: true, tenantId: true }).extend({ title: string2().min(1).optional() }).strict();
+}).omit({ id: true, tenantId: true, lastReviewedAt: true }).extend({ title: string2().min(1).optional() }).strict();
 var areaViewSchema = areaSchema.extend({
   title: string2(),
   archivedAt: exports_coerce.date().nullable().default(null),
@@ -19292,6 +19303,24 @@ var areaOverviewSchema = object({
   owner: areaOwnerLensSchema,
   areas: array(areaOverviewItemSchema)
 });
+var areaLookItemSchema = object({
+  id: string2(),
+  title: string2(),
+  by: string2().nullable().default(null),
+  why: string2().nullable().default(null)
+});
+var areaSinceLastLookSchema = object({
+  areaId: string2(),
+  lastReviewedAt: exports_coerce.date().nullable(),
+  since: exports_coerce.date(),
+  landed: array(areaLookItemSchema),
+  fresh: array(areaLookItemSchema),
+  stuck: array(areaLookItemSchema)
+});
+var restAreaInputSchema = object({
+  until: exports_iso.date(),
+  habits: _enum2(["keep", "pause"]).default("keep")
+}).strict();
 
 // ../../packages/schema/src/presets/facets.ts
 var PANTRY_DISPLAY_KIND = "pantry";
@@ -19924,6 +19953,136 @@ var timeBlockRangeQuerySchema = object({
   path: ["to"]
 });
 
+// ../../packages/schema/src/contracts/plans.ts
+var PLAN_KINDS = ["week", "day"];
+var PLAN_ITEM_ACTIONS = ["plan", "someday", "let_go"];
+var PLAN_ITEM_STATES = ["proposed", "accepted", "dismissed"];
+var PLAN_STATUSES = ["open", "settled", "replaced"];
+var PLAN_MAX_ITEMS = 60;
+var PLAN_REASON_MAX = 280;
+var PLAN_NOTE_MAX = 2000;
+var planKindSchema = _enum2(PLAN_KINDS);
+var planItemActionSchema = _enum2(PLAN_ITEM_ACTIONS);
+var planItemStateSchema = _enum2(PLAN_ITEM_STATES);
+var planStatusSchema = _enum2(PLAN_STATUSES);
+var civilDaySchema = string2().regex(/^\d{4}-\d{2}-\d{2}$/, "expected YYYY-MM-DD").refine((s) => new Date(`${s}T00:00:00Z`).toISOString().slice(0, 10) === s, "not a real day");
+var DAY_MS = 24 * 60 * 60 * 1000;
+function addCivilDays(day, n) {
+  return new Date(Date.parse(`${day}T00:00:00Z`) + n * DAY_MS).toISOString().slice(0, 10);
+}
+function planDays(kind, startsOn) {
+  return kind === "week" ? Array.from({ length: 7 }, (_, i) => addCivilDays(startsOn, i)) : [startsOn];
+}
+function isMonday(day) {
+  return new Date(`${day}T00:00:00Z`).getUTCDay() === 1;
+}
+var planItemInputSchema = object({
+  taskId: ulidSchema,
+  action: planItemActionSchema.default("plan"),
+  day: civilDaySchema.optional(),
+  at: exports_coerce.date().optional(),
+  durationMinutes: number2().int().min(5).max(24 * 60).optional(),
+  reason: string2().trim().min(1).max(PLAN_REASON_MAX).optional()
+}).strict().superRefine((v, ctx) => {
+  if (v.action === "plan") {
+    if (v.day === undefined === (v.at === undefined)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "a `plan` item takes exactly one of `day` or `at`",
+        path: ["day"]
+      });
+    }
+    if (v.durationMinutes !== undefined && v.at === undefined) {
+      ctx.addIssue({
+        code: "custom",
+        message: "`durationMinutes` goes with `at` (a time)",
+        path: ["durationMinutes"]
+      });
+    }
+  } else if (v.day !== undefined || v.at !== undefined || v.durationMinutes !== undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: `a \`${v.action}\` item takes no day, time or duration`,
+      path: ["action"]
+    });
+  }
+});
+var createPlanInputSchema = object({
+  kind: planKindSchema,
+  startsOn: civilDaySchema,
+  forUserId: string2().min(1).optional(),
+  note: string2().trim().min(1).max(PLAN_NOTE_MAX).optional(),
+  items: array(planItemInputSchema).min(1).max(PLAN_MAX_ITEMS)
+}).strict().superRefine((v, ctx) => {
+  if (v.kind === "week" && !isMonday(v.startsOn)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "a week plan starts on a Monday",
+      path: ["startsOn"]
+    });
+  }
+  const days = new Set(planDays(v.kind, v.startsOn));
+  const seen = new Set;
+  v.items.forEach((item, i) => {
+    if (seen.has(item.taskId)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "one item per task",
+        path: ["items", i, "taskId"]
+      });
+    }
+    seen.add(item.taskId);
+    if (item.day !== undefined && !days.has(item.day)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `the day falls outside the ${v.kind}`,
+        path: ["items", i, "day"]
+      });
+    }
+  });
+});
+var planDecisionInputSchema = object({ itemIds: array(string2().min(1)).min(1).max(PLAN_MAX_ITEMS).optional() }).strict();
+var planListQuerySchema = object({
+  kind: planKindSchema.optional(),
+  status: planStatusSchema.optional(),
+  startsOn: civilDaySchema.optional()
+});
+var planTaskSchema = object({
+  id: ulidSchema,
+  title: string2(),
+  status: taskStatusSchema,
+  scheduledAt: exports_coerce.date().nullable(),
+  allDay: boolean3(),
+  dueAt: exports_coerce.date().nullable(),
+  durationMinutes: number2().int().nullable(),
+  areaId: string2().nullable(),
+  projectId: string2().nullable()
+});
+var planItemViewSchema = object({
+  id: string2(),
+  taskId: ulidSchema,
+  action: planItemActionSchema,
+  scheduledAt: exports_coerce.date().nullable(),
+  allDay: boolean3(),
+  durationMinutes: number2().int().nullable(),
+  reason: string2().nullable(),
+  state: planItemStateSchema,
+  decidedAt: exports_coerce.date().nullable(),
+  task: planTaskSchema
+});
+var planViewSchema = object({
+  id: string2(),
+  kind: planKindSchema,
+  startsOn: civilDaySchema,
+  userId: string2(),
+  agentId: string2().nullable(),
+  note: string2().nullable(),
+  status: planStatusSchema,
+  createdAt: exports_coerce.date(),
+  updatedAt: exports_coerce.date(),
+  items: array(planItemViewSchema)
+});
+
 // ../../packages/schema/src/contracts/agent-chat.ts
 var agentConnectionSourceSchema = _enum2(["space", "env"]);
 var agentGatewayStatusSchema = _enum2(["connected", "offline", "not_connected"]);
@@ -20003,6 +20162,7 @@ var agentChangeSchema = object({
   changedAt: exports_coerce.date(),
   title: string2().nullable(),
   actor: actorRefSchema,
+  cursor: string2().optional(),
   fields: array(agentChangeFieldSchema).optional(),
   checkIn: object({
     value: number2(),
@@ -20017,7 +20177,8 @@ var agentChangesPageSchema = object({
 var agentChangesQuerySchema = object({
   since: string2().refine((s) => s === "now" || /^\d+-\d+$/.test(s), {
     message: "since must be a cursor from a prior page's nextCursor, or 'now'"
-  })
+  }),
+  node: string2().trim().min(1).max(64).optional()
 });
 var agentConfirmationKindSchema = _enum2(["delete", "cancel", "google", "orca", "bulk"]);
 var agentConfirmationStatusSchema = _enum2([
@@ -20660,16 +20821,21 @@ var EVERY_WEEKDAYS_RE = /\bevery\s+(?:weekday|weekdays|work\s?day|work\s?days)\b
 var EVERY_WEEKDAY_RE = new RegExp(`\\bevery\\s+(${WEEKDAY_ALT})\\b`, "i");
 var EVERY_UNIT_RE = /\bevery\s+(day|week|month|year)\b/i;
 var ADVERB_RE = /\b(daily|weekly|monthly|yearly|annually)\b/i;
-var RELATIVE_RE = /\b(today|tonight|tomorrow|tmrw|tmr)\b/i;
+var RELATIVE_RE = /\b(today|tonight|tomorrow|tmrw|tmr|yesterday)\b/i;
 var IN_N_RE = /\bin\s+(\d+)\s+(day|days|week|weeks|month|months)\b/i;
 var NEXT_UNIT_RE = /\bnext\s+(week|month|year)\b/i;
 var NEXT_WEEKDAY_RE = new RegExp(`\\bnext\\s+(${WEEKDAY_ALT})\\b`, "i");
 var THIS_WEEKDAY_RE = new RegExp(`\\bthis\\s+(${WEEKDAY_ALT})\\b`, "i");
+var LAST_WEEKDAY_RE = new RegExp(`\\blast\\s+(${WEEKDAY_ALT})\\b`, "i");
 var WEEKDAY_RE = new RegExp(`\\b(${WEEKDAY_ALT})\\b`, "i");
 var TIME_AMPM_RE = /\b(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)\b/i;
 var TIME_24H_RE = /\b(?:at\s+)?([01]?\d|2[0-3]):([0-5]\d)\b/;
 var NOON_RE = /\b(noon|midday)\b/i;
 var MIDNIGHT_RE = /\bmidnight\b/i;
+var DEADLINE_KEYWORD_RE = /\b(?:by|due(?:\s+on)?)\s+/gi;
+var ESTIMATE_HM_RE = /(?<!\bin\s+)\b(?:for\s+)?(\d{1,2})\s?h(?:ours?|rs?)?\s?(\d{1,2})\s?(?:m|mins?|minutes?)?\b/i;
+var ESTIMATE_H_RE = /(?<!\bin\s+)\b(?:for\s+)?(\d{1,2}(?:[.,]\d)?)\s?(?:h|hrs?|hours?)\b/i;
+var ESTIMATE_M_RE = /(?<!\bin\s+)\b(?:for\s+)?(\d{1,3})\s?(?:m|mins?|minutes?)\b/i;
 function blank(s, start, end) {
   return s.slice(0, start) + " ".repeat(end - start) + s.slice(end);
 }
@@ -20705,18 +20871,84 @@ function parseWhen(input, now) {
     scan = blank(scan, start, end);
     return { span, index: start };
   };
+  const deadline = takeDeadline(scan, now);
+  if (deadline) {
+    spans.push(deadline.span);
+    scan = blank(scan, deadline.span.start, deadline.span.end);
+  }
   const recurrence = takeRecurrence(scan, take);
   const date = takeDate(scan, take, now);
   const time = takeTime(scan, take);
+  const durationMinutes = takeEstimate(scan, take);
   const { scheduledAt, allDay } = resolveWhen({ now, recurrence, date, time });
   spans.sort((a, b) => a.start - b.start);
   return {
     ...scheduledAt ? { scheduledAt } : {},
     allDay,
     ...recurrence ? { recurrence } : {},
+    ...deadline ? { dueAt: deadline.at, dueAllDay: deadline.allDay } : {},
+    ...durationMinutes ? { durationMinutes } : {},
     spans
   };
 }
+function anchored(re) {
+  return new RegExp(`^${re.source.replace(/^\\b/, "")}`, re.flags.replace("g", ""));
+}
+var DEADLINE_DATES = [
+  IN_N_RE,
+  NEXT_WEEKDAY_RE,
+  THIS_WEEKDAY_RE,
+  NEXT_UNIT_RE,
+  RELATIVE_RE,
+  WEEKDAY_RE
+].map(anchored);
+var DEADLINE_TIMES = [TIME_AMPM_RE, TIME_24H_RE, NOON_RE, MIDNIGHT_RE].map(anchored);
+var accept = (m) => m?.index === undefined ? null : { span: { start: 0, end: 0, kind: "deadline" }, index: m.index };
+function firstMatch(text, res) {
+  for (const re of res) {
+    const m = re.exec(text);
+    if (m)
+      return m[0];
+  }
+  return null;
+}
+function takeDeadline(scan, now) {
+  for (const keyword of scan.matchAll(DEADLINE_KEYWORD_RE)) {
+    const start = keyword.index ?? 0;
+    let end = start + keyword[0].length;
+    const dateText = firstMatch(scan.slice(end), DEADLINE_DATES);
+    const date = dateText ? takeDate(dateText, accept, now) : null;
+    if (dateText && date)
+      end += dateText.length;
+    const gap = /^\s*/.exec(scan.slice(end))?.[0] ?? "";
+    const timeText = firstMatch(scan.slice(end + gap.length), DEADLINE_TIMES);
+    const time = timeText ? takeTime(timeText, accept) : null;
+    if (timeText && time)
+      end += gap.length + timeText.length;
+    if (!date && !time)
+      continue;
+    const day = date?.day ?? startOfDay(now);
+    const span = { start, end, kind: "deadline" };
+    if (!time)
+      return { at: day, allDay: true, span };
+    const at = new Date(day);
+    at.setHours(time.hours, time.minutes, 0, 0);
+    return { at, allDay: false, span };
+  }
+  return null;
+}
+function takeEstimate(scan, take) {
+  const hm = scan.match(ESTIMATE_HM_RE);
+  if (hm && take(hm, "estimate"))
+    return Number(hm[1]) * 60 + Number(hm[2]);
+  const h = scan.match(ESTIMATE_H_RE);
+  if (h && take(h, "estimate"))
+    return Math.round(Number((h[1] ?? "0").replace(",", ".")) * 60);
+  const m = scan.match(ESTIMATE_M_RE);
+  if (m && take(m, "estimate"))
+    return Number(m[1]);
+  return;
+}
 function takeRecurrence(scan, take) {
   const everyN = scan.match(EVERY_N_RE);
   if (everyN && take(everyN, "recurrence")) {
@@ -20781,11 +21013,18 @@ function takeDate(scan, take, now) {
       return on(addMonths(today, 1));
     return on(addMonths(today, 12));
   }
+  const lastWeekday = scan.match(LAST_WEEKDAY_RE);
+  if (lastWeekday && take(lastWeekday, "date")) {
+    const { dow } = weekdayByName(lastWeekday[1]);
+    return on(addDays(today, -((now.getDay() - dow + 7) % 7 || 7)));
+  }
   const relative = scan.match(RELATIVE_RE);
   if (relative && take(relative, "date")) {
     const word = (relative[1] ?? "").toLowerCase();
     if (word === "tonight")
       return on(today, true);
+    if (word === "yesterday")
+      return on(addDays(today, -1));
     return on(word === "today" ? today : addDays(today, 1));
   }
   const weekday = scan.match(WEEKDAY_RE);
@@ -20892,6 +21131,8 @@ function parseCapture(input, now) {
     ...starred ? { starred } : {},
     ...area ? { area } : {},
     ...when?.scheduledAt ? { scheduledAt: when.scheduledAt, allDay: when.allDay } : {},
+    ...when?.dueAt ? { dueAt: when.dueAt, ...when.scheduledAt ? {} : { allDay: when.dueAllDay } } : {},
+    ...when?.durationMinutes ? { durationMinutes: when.durationMinutes } : {},
     ...when?.recurrence ? { recurrence: when.recurrence } : {}
   };
 }
@@ -21351,7 +21592,7 @@ function parseCapture2(input, now) {
 
 // src/meta.ts
 var CLI_NAME = "do";
-var VERSION = "1.174.0";
+var VERSION = "1.175.0";
 var API_PREFIX = "/api/v1";
 var DEFAULT_API_URL = "http://localhost:3001";
 
@@ -21605,6 +21846,11 @@ var ENTITIES = [
         name: "ready",
         description: "only open tasks their Owner marked Ready for you; --ready=false for the rest",
         boolean: true
+      },
+      {
+        name: "drifted",
+        description: "only open tasks whose planned day moved 3+ times; --drifted=false for the rest",
+        boolean: true
       }
     ],
     write: {
@@ -21933,15 +22179,35 @@ var COMMAND_SPECS = [
       {
         name: "text",
         required: true,
-        description: "Task title; may embed #tag, ! (star) and ~area."
+        description: "Task title; may embed #tag, ! (star), ~area, a when, a deadline and an estimate (see grammar)."
+      }
+    ],
+    flags: [
+      {
+        name: "at",
+        type: "string",
+        description: "Plan it at this ISO date/time (overrides a when in the text). With a time ('2026-09-09T16:00:00+02:00') it is a timed task (allDay false) that shows on the calendar; a date only ('2026-09-09') is all-day."
+      },
+      {
+        name: "due",
+        type: "string",
+        description: "The Deadline, ISO date/time (overrides a by/due phrase in the text)."
+      },
+      {
+        name: "duration",
+        type: "string",
+        description: "How long it takes, in minutes (overrides an estimate in the text)."
       }
     ],
-    flags: [],
     scopes: ["tasks:write"],
     returns: "Task",
     grammar: {
       "#tag": "Adds a tag. Repeatable: '#home #urgent'.",
-      "!": "Stars the task \u2014 the 1\u20132 things that matter (aliases: !star/!s/!flag/!f). Drives Today's focus and the starred filter."
+      "!": "Stars the task \u2014 the 1\u20132 things that matter (aliases: !star/!s/!flag/!f). Drives Today's focus and the starred filter.",
+      "~area": "Files it into an existing Area by its title, case-insensitive: '~garden' for 'Garden'. One word (letters, digits, - and _), so an Area named with spaces can't be named here \u2014 file it after with `do tasks update <id> --data '{\"areaId\":\"<id>\"}'`. An unknown name files nothing (never creates an Area); the first ~area wins. Valid names: `do areas list --json` (their `title`).",
+      when: "The planned day and time: 'today', 'tomorrow 3pm', 'fri', 'next monday', 'in 3 days', 'at 16:00', 'tonight' (18:00); the past for back-filling: 'yesterday', 'last friday'. A time makes it a timed task (allDay false). 'every monday' / 'every 2 weeks' / 'daily' attaches a recurrence.",
+      "by / due": "The Deadline, never the plan: 'by friday', 'due fri', 'due tomorrow 5pm', 'by 17:00' (today). 'by' with no date after it ('pay by card') stays in the title.",
+      estimate: "How long it takes (durationMinutes): '30m', '45 min', '1h', '1.5h', '1h30', '2 hours', 'for 20 mins'. Not 'in 2 hours'."
     }
   },
   {
@@ -22121,6 +22387,84 @@ var COMMAND_SPECS = [
     returns: "Task",
     notes: "POST /api/v1/tasks/{id}/not-now (#889); 409 when the task isn't a proposal. Let go is `do task cancel`."
   },
+  {
+    path: ["plans", "list"],
+    summary: "Plan proposals: the weeks and days the agent proposed, newest first, each item with its answer.",
+    args: [],
+    flags: [
+      { name: "kind", type: "string", description: "week or day." },
+      { name: "status", type: "string", description: "open, settled or replaced." },
+      {
+        name: "starts-on",
+        type: "string",
+        description: "The week's Monday, or the day (YYYY-MM-DD)."
+      },
+      { name: "for", type: "string", description: "Only this member's plans (user id)." }
+    ],
+    scopes: ["tasks:read"],
+    returns: "Plan[]",
+    notes: "GET /api/v1/plans (#912): the latest 20."
+  },
+  {
+    path: ["plans", "get"],
+    summary: "One plan proposal with its items and each item's task as it is now.",
+    args: [{ name: "id", required: true, description: "Plan id." }],
+    flags: [],
+    scopes: ["tasks:read"],
+    returns: "Plan",
+    notes: "GET /api/v1/plans/{id} (#912)."
+  },
+  {
+    path: ["plans", "propose"],
+    summary: "Propose a week (or a day) for a member: plan tasks on a day or at a time, back to Someday, or Let go. Nothing changes until the member accepts.",
+    args: [],
+    flags: [
+      {
+        name: "data",
+        type: "string",
+        description: 'The CreatePlanInput as JSON: {"kind":"week","startsOn":"2026-10-19","note":"\u2026","items":[{"taskId":"\u2026","day":"2026-10-20","reason":"Deadline Friday"},{"taskId":"\u2026","at":"2026-10-21T09:00:00Z","durationMinutes":45},{"taskId":"\u2026","action":"someday"},{"taskId":"\u2026","action":"let_go"}]}.'
+      }
+    ],
+    scopes: ["tasks:write"],
+    returns: "Plan",
+    notes: "POST /api/v1/plans (#912). A week starts on a Monday; days are the member's, times are ISO instants inside the week. `forUserId` names the member (default: the member the key acts for). A newer plan for the same week or day replaces the open one."
+  },
+  {
+    path: ["plans", "accept"],
+    summary: "Accept a plan's proposed items (all of them, or the item ids given): each task is written as the item says.",
+    args: [
+      { name: "id", required: true, description: "Plan id." },
+      { name: "items", required: false, description: "Item ids (default: every proposed item)." }
+    ],
+    flags: [],
+    scopes: ["tasks:write"],
+    returns: "Plan",
+    notes: "POST /api/v1/plans/{id}/accept (#912). Undo with `do plans undo`."
+  },
+  {
+    path: ["plans", "dismiss"],
+    summary: "Leave a plan's proposed items out (all of them, or the item ids given).",
+    args: [
+      { name: "id", required: true, description: "Plan id." },
+      { name: "items", required: false, description: "Item ids (default: every proposed item)." }
+    ],
+    flags: [],
+    scopes: ["tasks:write"],
+    returns: "Plan",
+    notes: "POST /api/v1/plans/{id}/dismiss (#912). Nothing is written to a task."
+  },
+  {
+    path: ["plans", "undo"],
+    summary: "Undo a plan's answers (all of them, or the item ids given): accepted tasks go back as they were.",
+    args: [
+      { name: "id", required: true, description: "Plan id." },
+      { name: "items", required: false, description: "Item ids (default: every answered item)." }
+    ],
+    flags: [],
+    scopes: ["tasks:write"],
+    returns: "Plan",
+    notes: "POST /api/v1/plans/{id}/undo (#912). The items read as proposed again."
+  },
   {
     path: ["tasks", "ready"],
     summary: "Mark a task Ready for you: its Owner finished something the member should look at (a draft, a link, a worktree).",
@@ -22150,7 +22494,35 @@ var COMMAND_SPECS = [
     args: [{ name: "id", required: true, description: "Task ULID." }],
     flags: [
       { name: "days", type: "string", description: "Days from now to reschedule.", default: "1" },
-      { name: "until", type: "string", description: "Absolute date/time (ISO) to reschedule to." }
+      {
+        name: "until",
+        type: "string",
+        description: "Absolute date/time (ISO) to reschedule to. With a time it becomes a timed task (allDay false); a date only stays all-day."
+      },
+      {
+        name: "duration",
+        type: "string",
+        description: "How long it takes, in minutes (sets durationMinutes)."
+      }
+    ],
+    scopes: ["tasks:write"],
+    returns: "Task"
+  },
+  {
+    path: ["task", "schedule"],
+    summary: "Plan a task at a day or a time, so a timed one shows on the calendar.",
+    args: [{ name: "id", required: true, description: "Task ULID." }],
+    flags: [
+      {
+        name: "at",
+        type: "string",
+        description: "Required. ISO date/time. With a time ('2026-09-09T16:00:00+02:00') the task is timed (allDay false); a date only ('2026-09-09') is all-day."
+      },
+      {
+        name: "duration",
+        type: "string",
+        description: "How long it takes, in minutes (sets durationMinutes)."
+      }
     ],
     scopes: ["tasks:write"],
     returns: "Task"
@@ -22750,6 +23122,22 @@ var COMMAND_SPECS = [
     returns: "EchoThread",
     notes: "When the current thread is still empty, that one is returned instead."
   },
+  {
+    path: ["echo", "threads", "push"],
+    summary: "Set what one of your agent threads may push to your devices.",
+    args: [
+      { name: "id", required: true, description: "Thread ULID (see `echo threads list`)." },
+      {
+        name: "setting",
+        required: true,
+        description: "all (Needs you, and Told quietly), needs_you (only what waits on you) or off."
+      }
+    ],
+    flags: [],
+    scopes: ["agents:write"],
+    returns: "EchoThreadSummary",
+    notes: "For later and Silent posts never push. The home thread and conversations start at all, a standing thread you add at needs_you."
+  },
   {
     path: ["settings", "get"],
     summary: "Show the caller's settings for the Space.",
@@ -23062,12 +23450,17 @@ var COMMAND_SPECS = [
       {
         name: "until",
         type: "string",
-        description: "The day it's back (YYYY-MM-DD). Required."
+        description: "The day it's back (YYYY-MM-DD, after today). Required."
+      },
+      {
+        name: "pause-habits",
+        type: "boolean",
+        description: "Pause the Area's habits until then too (they keep going otherwise)."
       }
     ],
     scopes: ["areas:write"],
     returns: "AreaView",
-    notes: "PATCH /api/v1/areas/{id} { restingUntil }. Between active and archived: its attention reads Resting, back in that month. Bring it back early with `do areas back`."
+    notes: "POST /api/v1/areas/{id}/rest { until, habits } (Areas 8). Between active and archived: its attention reads Resting, Focus, Review and filing leave it alone, and its recurring tasks pause. Bring it back early with `do areas back`."
   },
   {
     path: ["areas", "back"],
@@ -23076,7 +23469,25 @@ var COMMAND_SPECS = [
     flags: [],
     scopes: ["areas:write"],
     returns: "AreaView",
-    notes: "PATCH /api/v1/areas/{id} { restingUntil: null }. Nothing was lost while it rested."
+    notes: "POST /api/v1/areas/{id}/back (Areas 8). The habits it paused come back too, and the recurring tasks' occurrences that went by while it rested are skipped. Nothing was lost."
+  },
+  {
+    path: ["areas", "since"],
+    summary: "What happened in an Area since you last looked: landed, new, and what seems stuck.",
+    args: [{ name: "id", required: true, description: "Area ULID." }],
+    flags: [],
+    scopes: ["areas:read"],
+    returns: "AreaSinceLastLook",
+    notes: 'GET /api/v1/areas/{id}/since-last-look (Areas 6). A few of each, named, never tallied; stuck ones say why in words ("Deadline was 12 October").'
+  },
+  {
+    path: ["areas", "looked-at"],
+    summary: "Record a look at an Area: its review rhythm starts again from now.",
+    args: [{ name: "id", required: true, description: "Area ULID." }],
+    flags: [],
+    scopes: ["areas:write"],
+    returns: "AreaView",
+    notes: "POST /api/v1/areas/{id}/looked-at (Areas 6). The Area leaves Review until its rhythm (weekly, monthly, quarterly) comes round."
   },
   {
     path: ["areas", "focus"],
@@ -23797,18 +24208,52 @@ function renderToday(data, mode) {
 ${habits.join(`
 `)}` : tasks;
 }
-var DAY_MS = 24 * 60 * 60 * 1000;
+var DAY_MS2 = 24 * 60 * 60 * 1000;
 function plannedDay(at, from) {
   if (!at)
     return "earlier";
   const day = new Date(at);
-  const ago = from ? Math.round((Date.parse(from) - day.getTime()) / DAY_MS) : 7;
+  const ago = from ? Math.round((Date.parse(from) - day.getTime()) / DAY_MS2) : 7;
   if (ago <= 1)
     return "yesterday";
   if (ago < 7)
     return day.toLocaleDateString("en-GB", { weekday: "long" });
   return day.toLocaleDateString("en-GB", { day: "numeric", month: "short" });
 }
+function planItemWords(i) {
+  if (i.action === "someday")
+    return "back to Someday";
+  if (i.action === "let_go")
+    return "let go";
+  if (!i.scheduledAt)
+    return "planned";
+  const at = new Date(i.scheduledAt);
+  const day = at.toLocaleDateString("en-GB", { weekday: "short", day: "numeric", month: "short" });
+  return i.allDay ? day : `${day} ${at.toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" })}`;
+}
+function renderPlan(data, mode) {
+  const p = data;
+  const head = `${p.kind === "day" ? "Day" : "Week"} of ${p.startsOn ?? "?"} \xB7 ${p.status ?? "?"}`;
+  const items = (p.items ?? []).map((i) => {
+    const state = i.state === "proposed" ? "\xB7" : i.state === "accepted" ? "\u2713" : "\u2013";
+    const reason = i.reason ? paint(mode, "dim", ` \u2014 ${i.reason}`) : "";
+    return `  ${state} ${i.task?.title ?? "(untitled)"}: ${planItemWords(i)}${reason}  ${paint(mode, "dim", i.id)}`;
+  });
+  return [
+    `${paint(mode, "bold", head)}  ${paint(mode, "dim", p.id)}`,
+    ...p.note ? [paint(mode, "dim", p.note)] : [],
+    ...items
+  ].join(`
+`);
+}
+function renderPlans(data, mode) {
+  const plans = data ?? [];
+  if (plans.length === 0)
+    return paint(mode, "dim", "No plans.");
+  return plans.map((p) => renderPlan(p, mode)).join(`
+
+`);
+}
 function renderFromEarlier(data, mode) {
   const d = data;
   const tasks = d.tasks ?? [];
@@ -23848,6 +24293,28 @@ function renderAreaOverview(data, mode) {
   return out.join(`
 `);
 }
+function renderSinceLastLook(data, mode) {
+  const d = data;
+  const day = new Date(d.since).toLocaleDateString("en-GB", { day: "numeric", month: "long" });
+  const out = [
+    paint(mode, "bold", d.lastReviewedAt ? `Since you last looked, on ${day}` : `Since ${day} (never looked at)`)
+  ];
+  const group = (label, items, line) => {
+    if (items.length === 0)
+      return;
+    out.push(`  ${label}`);
+    for (const i of items)
+      out.push(`    \xB7 ${line(i)}`);
+  };
+  group("Landed", d.landed, (i) => i.by ? `${i.title} (${i.by})` : i.title);
+  group("New", d.fresh, (i) => i.title);
+  group("Stuck?", d.stuck, (i) => i.why ? `${i.title} ${paint(mode, "dim", `\xB7 ${i.why}`)}` : i.title);
+  if (d.landed.length + d.fresh.length + d.stuck.length === 0) {
+    out.push(paint(mode, "dim", "  Nothing landed, new or stuck."));
+  }
+  return out.join(`
+`);
+}
 function renderFromEarlierAnswer(data, mode) {
   const d = data;
   const n = d.tasks ?? 0;
@@ -24279,9 +24746,24 @@ function renderProgress(data, mode) {
   }
   const areas = p.areas ?? [];
   if (areas.length > 0) {
-    out.push("", paint(mode, "bold", "Areas"));
-    for (const a of areas)
-      out.push(`  ${a.name}: ${a.tasksDone}`);
+    out.push("", paint(mode, "bold", "Where your attention went"));
+    if (p.areasHighlight)
+      out.push(`  ${p.areasHighlight}`);
+    for (const a of areas) {
+      const total = a.total ?? a.tasksDone;
+      if (a.total === undefined) {
+        out.push(`  ${a.name}: ${total}`);
+        continue;
+      }
+      const mine = (a.tasksDoneMine ?? 0) + (a.habitsDone ?? 0) + (a.blocksDone ?? 0);
+      const parts = [
+        `${a.tasksDone} task(s)`,
+        `${a.habitsDone ?? 0} check-in(s)`,
+        `${a.blocksDone ?? 0} block(s)`
+      ].join(", ");
+      const split = a.tasksDoneAgents ? ` \xB7 you ${mine}, agents ${a.tasksDoneAgents}` : "";
+      out.push(`  ${a.name}: ${total}${split} ${paint(mode, "dim", `(${parts}; ${a.previousTotal ?? 0} before)`)}`);
+    }
   }
   const habits = p.habits ?? [];
   if (habits.length > 0) {
@@ -24587,11 +25069,17 @@ function runFixed(spec, ctx) {
   return handler(ctx);
 }
 var HANDLERS = {
-  capture: async ({ args, io, requireClient }) => {
+  capture: async ({ args, flags, io, requireClient }) => {
     const text = args.join(" ").trim();
     if (text.length === 0)
       throw usageError('capture needs some text, e.g. `do capture "call mum #family"`');
     const parsed = parseCapture2(text, io.now());
+    const at = flagInstant(flags, "at");
+    const due = flagInstant(flags, "due");
+    const duration = flagMinutes(flags, "duration") ?? parsed.durationMinutes;
+    const scheduledAt = at?.at ?? parsed.scheduledAt;
+    const dueAt = due?.at ?? parsed.dueAt;
+    const allDay = at ? at.allDay : parsed.scheduledAt ? parsed.allDay : due?.allDay ?? parsed.allDay;
     const id = ulid3();
     const input = parseInput(createTaskInputSchema, {
       id,
@@ -24599,7 +25087,10 @@ var HANDLERS = {
       tags: parsed.tags,
       ...parsed.starred ? { starred: parsed.starred } : {},
       ...parsed.area ? { areaName: parsed.area } : {},
-      ...parsed.scheduledAt ? { scheduledAt: parsed.scheduledAt, allDay: parsed.allDay } : {}
+      ...scheduledAt ? { scheduledAt } : {},
+      ...dueAt ? { dueAt } : {},
+      ...scheduledAt || dueAt ? { allDay } : {},
+      ...duration ? { durationMinutes: duration } : {}
     });
     const client = requireClient();
     const task = await client.post("/tasks", input);
@@ -24909,6 +25400,30 @@ var HANDLERS = {
     const id = requireArg(args, 0, "task id");
     return { data: await requireClient().post(`/tasks/${id}/not-now`, {}), render: renderTask };
   },
+  "plans list": async ({ flags, requireClient }) => {
+    const plans = await requireClient().get("/plans", {
+      query: {
+        kind: flagString(flags, "kind"),
+        status: flagString(flags, "status"),
+        startsOn: flagString(flags, "starts-on"),
+        forUserId: flagString(flags, "for")
+      }
+    });
+    return { data: plans, render: renderPlans };
+  },
+  "plans get": async ({ args, requireClient }) => {
+    const id = requireArg(args, 0, "plan id");
+    return { data: await requireClient().get(`/plans/${id}`), render: renderPlan };
+  },
+  "plans propose": async ({ flags, requireClient }) => {
+    if (flagString(flags, "data") === undefined)
+      throw usageError("plans propose needs --data");
+    const body = parseInput(createPlanInputSchema, readDataFlag(flags));
+    return { data: await requireClient().post("/plans", body), render: renderPlan };
+  },
+  "plans accept": async (ctx) => planDecision(ctx, "accept"),
+  "plans dismiss": async (ctx) => planDecision(ctx, "dismiss"),
+  "plans undo": async (ctx) => planDecision(ctx, "undo"),
   "tasks ready": async ({ args, flags, requireClient }) => {
     const id = requireArg(args, 0, "task id");
     const note = flagString(flags, "note");
@@ -24923,7 +25438,26 @@ var HANDLERS = {
   "task snooze": async ({ args, flags, io, requireClient }) => {
     const id = requireArg(args, 0, "task id");
     const target = computeSnoozeTarget(flags, io.now());
-    const body = parseInput(updateTaskInputSchema, { scheduledAt: target });
+    const until = flagInstant(flags, "until");
+    const duration = flagMinutes(flags, "duration");
+    const body = parseInput(updateTaskInputSchema, {
+      scheduledAt: target,
+      ...until ? { allDay: until.allDay } : {},
+      ...duration ? { durationMinutes: duration } : {}
+    });
+    return { data: await requireClient().patch(`/tasks/${id}`, body), render: renderTask };
+  },
+  "task schedule": async ({ args, flags, requireClient }) => {
+    const id = requireArg(args, 0, "task id");
+    const at = flagInstant(flags, "at");
+    if (!at)
+      throw usageError("task schedule needs --at, e.g. --at '2026-09-09T16:00:00+02:00'");
+    const duration = flagMinutes(flags, "duration");
+    const body = parseInput(updateTaskInputSchema, {
+      scheduledAt: at.at,
+      allDay: at.allDay,
+      ...duration ? { durationMinutes: duration } : {}
+    });
     return { data: await requireClient().patch(`/tasks/${id}`, body), render: renderTask };
   },
   "habit log": async ({ args, flags, requireClient }) => {
@@ -25155,6 +25689,12 @@ var HANDLERS = {
     data: await requireClient().post("/echo/threads", {}),
     render: renderEchoThread
   }),
+  "echo threads push": async ({ args, requireClient }) => ({
+    data: await requireClient().patch(`/echo/threads/${requireArg(args, 0, "thread id")}`, {
+      push: requireArg(args, 1, "push setting (needs_you, all or off)")
+    }),
+    render: renderRecord
+  }),
   "settings get": async ({ requireClient }) => ({
     data: await requireClient().get("/settings"),
     render: renderRecord
@@ -25356,13 +25896,32 @@ var HANDLERS = {
     const until = flagString(flags, "until");
     if (!until)
       throw usageError("areas rest needs --until <YYYY-MM-DD>, the day it's back");
-    const input = parseInput(updateAreaInputSchema, { restingUntil: until });
-    return { data: await requireClient().patch(`/areas/${id}`, input), render: renderRecord };
+    const input = parseInput(restAreaInputSchema, {
+      until,
+      habits: flagBool(flags, "pause-habits") ? "pause" : "keep"
+    });
+    return { data: await requireClient().post(`/areas/${id}/rest`, input), render: renderRecord };
   },
   "areas back": async ({ args, requireClient }) => {
     const id = requireArg(args, 0, "area id");
-    const input = parseInput(updateAreaInputSchema, { restingUntil: null });
-    return { data: await requireClient().patch(`/areas/${id}`, input), render: renderRecord };
+    return {
+      data: await requireClient().post(`/areas/${id}/back`, undefined),
+      render: renderRecord
+    };
+  },
+  "areas since": async ({ args, requireClient }) => {
+    const id = requireArg(args, 0, "area id");
+    return {
+      data: await requireClient().get(`/areas/${id}/since-last-look`),
+      render: renderSinceLastLook
+    };
+  },
+  "areas looked-at": async ({ args, requireClient }) => {
+    const id = requireArg(args, 0, "area id");
+    return {
+      data: await requireClient().post(`/areas/${id}/looked-at`, undefined),
+      render: renderRecord
+    };
   },
   "areas focus": async ({ args, flags, requireClient }) => {
     const off = flagBool(flags, "off");
@@ -25651,6 +26210,12 @@ function assertConfigKey(key) {
     throw usageError(`unknown config key \`${key}\` \u2014 valid keys: ${CONFIG_KEYS.join(", ")}`);
   }
 }
+async function planDecision({ args, requireClient }, verb) {
+  const id = requireArg(args, 0, "plan id");
+  const itemIds = args.slice(1);
+  const body = parseInput(planDecisionInputSchema, itemIds.length > 0 ? { itemIds } : {});
+  return { data: await requireClient().post(`/plans/${id}/${verb}`, body), render: renderPlan };
+}
 function parseInput(schema, value) {
   const result = schema.safeParse(value);
   if (!result.success) {
@@ -25659,14 +26224,29 @@ function parseInput(schema, value) {
   }
   return result.data;
 }
+function flagInstant(flags, name) {
+  const raw = flagString(flags, name);
+  if (raw === undefined)
+    return;
+  const dayOnly = /^\d{4}-\d{2}-\d{2}$/.exec(raw.trim());
+  const at = dayOnly ? new Date(`${raw.trim()}T00:00:00`) : new Date(raw);
+  if (Number.isNaN(at.getTime()))
+    throw usageError(`--${name} is not a valid date: ${raw}`);
+  return { at, allDay: dayOnly !== null };
+}
+function flagMinutes(flags, name) {
+  const raw = flagString(flags, name);
+  if (raw === undefined)
+    return;
+  const minutes = Number(raw);
+  if (!Number.isInteger(minutes) || minutes <= 0)
+    throw usageError(`--${name} must be a whole number of minutes`);
+  return minutes;
+}
 function computeSnoozeTarget(flags, now) {
-  const until = flagString(flags, "until");
-  if (until !== undefined) {
-    const date = new Date(until);
-    if (Number.isNaN(date.getTime()))
-      throw usageError(`--until is not a valid date: ${until}`);
-    return date;
-  }
+  const until = flagInstant(flags, "until");
+  if (until)
+    return until.at;
   const daysRaw = flagString(flags, "days") ?? "1";
   const days = Number(daysRaw);
   if (!Number.isFinite(days) || days <= 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robbeverhelst/do",
-  "version": "1.174.0",
+  "version": "1.175.0",
   "private": false,
   "description": "do — the agent-drivable CLI over the public /api/v1 surface",
   "homepage": "https://github.com/robbeverhelst/do/tree/main/apps/cli",