@ethlete/agent-rules 0.1.0-next.16 → 0.1.0-next.18

package/src/lib/timetrack-command.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.timetrackCommand = void 0;
 const tslib_1 = require("tslib");
 const fs_1 = require("fs");
+const path_1 = require("path");
 const timetrack_1 = require("./timetrack");
 const plain_text_1 = require("./plain-text");
 const git_1 = require("./git");
@@ -29,33 +30,65 @@ const FLAGS_WITH_VALUE = [
     '--paths',
     '--claim',
     '--author',
+    '--plan',
+    '--delete',
+    '--repo',
+    '--name',
+    '--rename',
+    '--merge',
+    '--into',
 ];
 /** Every human-readable line, with anything a terminal would act on printed rather than obeyed. */
 const say = (line) => console.log((0, plain_text_1.plain)(line));
 const positionalArgs = (args) => args.filter((entry, index) => { var _a; return !entry.startsWith('--') && !FLAGS_WITH_VALUE.includes((_a = args[index - 1]) !== null && _a !== void 0 ? _a : ''); });
 const flagValue = (args, flag) => {
     const index = args.indexOf(flag);
-    return index === -1 ? undefined : args[index + 1];
+    if (index === -1)
+        return undefined;
+    const value = args[index + 1];
+    if (value === undefined || value.startsWith('--'))
+        throw new Error(`${flag} needs a value.`);
+    return value;
 };
 const numberFlag = (args, flag) => {
     const raw = flagValue(args, flag);
     if (raw === undefined)
         return undefined;
-    const value = Number(raw);
+    const value = raw.trim() ? Number(raw) : Number.NaN;
     if (!Number.isFinite(value))
         throw new Error(`${flag} takes a number, not ${raw}.`);
     return value;
 };
-/** `--at` takes anything `Date` reads, so an agent may pass an ISO instant or leave it out for now. */
-const instantFlag = (args) => {
-    const raw = flagValue(args, '--at');
-    if (!raw)
-        return Date.now();
-    const at = new Date(raw);
+const countFlag = (args, flag) => {
+    const value = numberFlag(args, flag);
+    if (value !== undefined && (!Number.isInteger(value) || value <= 0)) {
+        throw new Error(`${flag} takes a whole number above zero, not ${value}.`);
+    }
+    return value;
+};
+const LOCAL_DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+const LOCAL_CLOCK = /^(\d{1,2}):(\d{2})$/;
+/**
+ * Reads an instant flag. A date alone is local midnight and a clock alone is that time today, where
+ * `Date` would read the first as UTC and refuse the second; anything else goes to `Date` as it is.
+ */
+const instantOf = (flag, raw) => {
+    const date = LOCAL_DATE.exec(raw);
+    const clock = LOCAL_CLOCK.exec(raw);
+    const today = new Date();
+    const at = date
+        ? new Date(Number(date[1]), Number(date[2]) - 1, Number(date[3]))
+        : clock
+            ? new Date(today.getFullYear(), today.getMonth(), today.getDate(), Number(clock[1]), Number(clock[2]))
+            : new Date(raw);
     if (Number.isNaN(at.getTime()))
-        throw new Error(`--at takes a date, not ${raw}.`);
+        throw new Error(`${flag} takes a date, not ${raw}.`);
     return at.getTime();
 };
+const instantFlag = (args) => {
+    const raw = flagValue(args, '--at');
+    return raw ? instantOf('--at', raw) : Date.now();
+};
 const issueLine = (issue) => [
     issue.key,
     issue.issueType,
@@ -182,12 +215,110 @@ const rowLine = (row) => {
         (_c = row.laneKey) !== null && _c !== void 0 ? _c : 'no lane',
     ].join('  ');
 };
-/** `--from` and `--to` take anything `Date` reads, so a caller may pass an ISO instant or a clock. */
-const instantOf = (flag, raw) => {
-    const at = new Date(raw);
-    if (Number.isNaN(at.getTime()))
-        throw new Error(`${flag} takes a date, not ${raw}.`);
-    return at.getTime();
+const shiftDay = (day, days) => {
+    const [year, month, date] = day.split('-').map(Number);
+    const shifted = new Date(year, month - 1, date + days);
+    return `${shifted.getFullYear()}-${pad(shifted.getMonth() + 1)}-${pad(shifted.getDate())}`;
+};
+const minutesOf = (ms) => Math.round(ms / MINUTE_MS);
+const tempoDayLines = (worklogs) => {
+    var _a, _b, _c;
+    const days = new Map();
+    for (const worklog of worklogs) {
+        const issues = (_a = days.get(worklog.day)) !== null && _a !== void 0 ? _a : new Map();
+        const key = (_b = worklog.issueKey) !== null && _b !== void 0 ? _b : `#${worklog.issueId}`;
+        issues.set(key, ((_c = issues.get(key)) !== null && _c !== void 0 ? _c : 0) + worklog.durationMs);
+        days.set(worklog.day, issues);
+    }
+    return [...days]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([day, issues]) => {
+        const total = [...issues.values()].reduce((sum, ms) => sum + ms, 0);
+        const parts = [...issues]
+            .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+            .map(([key, ms]) => `${key} ${minutesOf(ms)}m`);
+        return `${day}  ${hours(total)}  ${parts.join('  ')}`;
+    });
+};
+const syncWriteLine = (write) => {
+    var _a;
+    return [
+        write.kind.padEnd(6),
+        (_a = write.issueKey) !== null && _a !== void 0 ? _a : write.proposalId,
+        `${clock(write.fromMs)}-${clock(write.fromMs + write.durationMs)}`,
+        `${minutesOf(write.durationMs)}m`,
+        write.reason,
+        ...(write.tempoWorklogId ? [`worklog ${write.tempoWorklogId}`] : []),
+        write.description || '(no description)',
+        ...(write.blocked ? [`HELD BACK: ${write.blocked}`] : []),
+    ].join('  ');
+};
+/** What a sync of a day would write, row by row, and what it leaves alone. */
+const syncPlanLines = (plan) => {
+    const count = (kind) => plan.writes.filter((write) => write.kind === kind).length;
+    const blocked = plan.writes.filter((write) => write.blocked).length;
+    return [
+        plan.writes.length
+            ? `${plan.day}  plan ${plan.planHash}  ${count('create')} create, ${count('update')} update, ${count('delete')} delete`
+            : `${plan.day}  nothing to write`,
+        ...plan.writes.map((write) => `  ${syncWriteLine(write)}`),
+        `${plan.unchanged} unchanged, ${plan.skipped} skipped (still awaiting review)`,
+        ...(blocked ? [`${blocked} row(s) held back: Tempo would refuse them until they are fixed on the day.`] : []),
+        ...(plan.unresolvedKeys.length
+            ? [`Jira does not know ${plan.unresolvedKeys.join(', ')}, so nothing is written for those rows.`]
+            : []),
+        ...(plan.coveredMs
+            ? [`${minutesOf(plan.coveredMs)}m of the day is already logged by foreign worklogs, so it is left out.`]
+            : []),
+        `Foreign worklogs (${plan.foreign.length}), never touched`,
+        ...plan.foreign.map((worklog) => { var _a; return `  ${(_a = worklog.issueKey) !== null && _a !== void 0 ? _a : `#${worklog.issueId}`}  ${clock(worklog.fromMs)}  ${minutesOf(worklog.durationMs)}m  ${worklog.description || '(no description)'}`; }),
+    ];
+};
+/** Every row a write attempted, and what the user has to do about the ones that did not land. */
+const syncRunLines = (run) => [
+    ...run.rows.map((row) => {
+        var _a;
+        return [
+            row.status.padEnd(7),
+            row.kind.padEnd(6),
+            (_a = row.issueKey) !== null && _a !== void 0 ? _a : row.proposalId,
+            ...(row.tempoWorklogId ? [`worklog ${row.tempoWorklogId}`] : []),
+            ...(row.detail ? [row.detail] : []),
+        ].join('  ');
+    }),
+    ...(run.retryCount
+        ? [
+            `${run.retryCount} row(s) did not land. Retry them on the Sync page, which retries this run's own plan: a new plan read straight after a write can miss what Tempo just took.`,
+        ]
+        : []),
+    ...(run.unrecorded
+        ? [
+            `Written, but not recorded: ${run.unrecorded}. Tempo holds these worklogs and the app no longer owns them. Delete them in Tempo before writing this day again, or the time is logged twice.`,
+        ]
+        : []),
+];
+const meetingMs = (events) => events
+    .filter((event) => !event.allDay && event.response !== 'declined')
+    .reduce((sum, event) => sum + event.endMs - event.startMs, 0);
+const calendarEventLine = (event) => {
+    const start = new Date(event.startMs);
+    const when = event.allDay
+        ? 'all-day'
+        : `${pad(start.getHours())}:${pad(start.getMinutes())} ${minutesOf(event.endMs - event.startMs)}m`;
+    const answer = event.response === 'accepted' || event.response === 'organizer' ? [] : [event.response];
+    return [when, event.title, ...answer].join('  ');
+};
+const calendarDayLines = (events) => {
+    var _a;
+    const days = new Map();
+    for (const event of events)
+        days.set(event.day, [...((_a = days.get(event.day)) !== null && _a !== void 0 ? _a : []), event]);
+    return [...days]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .flatMap(([day, dayEvents]) => [
+        `${day}  ${dayEvents.length} event(s), ${hours(meetingMs(dayEvents))}`,
+        ...dayEvents.map((event) => `  ${calendarEventLine(event)}`),
+    ]);
 };
 /** Which edits the flags name. `--from` with `--to` is the one pair that names a single change. */
 const namedEdits = (argv) => {
@@ -256,7 +387,7 @@ const writeExport = (options) => {
         (0, fs_1.unlinkSync)(path);
     const handle = (0, fs_1.openSync)(path, 'wx', 0o600);
     try {
-        (0, fs_1.writeSync)(handle, data);
+        (0, fs_1.writeFileSync)(handle, data);
     }
     finally {
         (0, fs_1.closeSync)(handle);
@@ -268,6 +399,49 @@ const printed = (value, json) => {
         console.log(JSON.stringify(value, null, 2));
     return 0;
 };
+/** Every write waits in the app for the user's press, so what a write prints is where to look next. */
+const queuedLines = (queued, what) => [
+    `Queued in Timetrack for the user's approval: ${what}.`,
+    `Nothing is written until they approve it. Read the outcome with: timetrack approval ${queued.approvalId}`,
+];
+const printedQueued = (options) => {
+    if (!options.json)
+        queuedLines(options.queued, options.what).forEach(say);
+    return printed(options.queued, options.json);
+};
+const isSyncWithRun = (value) => typeof value === 'object' && value !== null && 'run' in value && typeof value.run === 'object';
+const UNDECIDED = {
+    queued: "still waits for the user's approval in Timetrack.",
+    rejected: 'the user rejected it. Nothing was written.',
+    expired: 'expired at the end of the day it was asked on. Nothing was written. Ask again.',
+};
+const approvalLines = (found) => {
+    if (found.status !== 'approved')
+        return [`${found.approvalId}  ${UNDECIDED[found.status]}`];
+    if (found.error !== undefined)
+        return [`${found.approvalId}  approved, but it failed: ${found.error}`];
+    const unrecorded = unrecordedOf(found.result);
+    return [
+        `${found.approvalId}  approved and carried out.`,
+        ...(isSyncWithRun(found.result) ? syncRunLines(found.result.run) : ['Pass --json for what it answered.']),
+        ...(unrecorded && !isSyncWithRun(found.result)
+            ? [`Carried out, but the app's ledger did not follow: ${unrecorded}. A later sync may undo it.`]
+            : []),
+    ];
+};
+const unrecordedOf = (value) => typeof value === 'object' && value !== null && 'unrecorded' in value && typeof value.unrecorded === 'string'
+    ? value.unrecorded
+    : undefined;
+/** Non-zero for anything that did not land in full, so a caller polling in a script can tell. */
+const approvalExitCode = (found) => {
+    if (found.status === 'queued')
+        return 0;
+    if (found.status !== 'approved' || found.error !== undefined)
+        return 1;
+    if (unrecordedOf(found.result))
+        return 1;
+    return isSyncWithRun(found.result) && (found.result.run.retryCount || found.result.run.unrecorded) ? 1 : 0;
+};
 /**
  * Cuts a placeholder that covered a whole checkout into one per directory its commits worked in.
  *
@@ -303,16 +477,8 @@ const splitStandIn = (options) => tslib_1.__awaiter(void 0, void 0, void 0, func
     const claim = flagValue(argv, '--claim');
     const apply = argv.includes('--force');
     const projectRoots = (0, git_1.projectRootsOf)(checkout);
-    const answer = yield (0, timetrack_1.timetrackSplitStandIn)({
-        id,
-        branch,
-        repoPath,
-        commits,
-        projectRoots,
-        paths,
-        claim,
-        apply,
-    });
+    const request = { id, branch, repoPath, commits, projectRoots, paths, claim };
+    const answer = yield (0, timetrack_1.timetrackSplitStandIn)(request);
     if (!json) {
         say(`${standIn.name}  ${standIn.days.length} day(s), branch ${branch}`);
         say(`Directories the commits name (${answer.candidates.length})`);
@@ -320,10 +486,7 @@ const splitStandIn = (options) => tslib_1.__awaiter(void 0, void 0, void 0, func
         if (!answer.pieces.length) {
             say('None of them is an automatic grain. Pick the pieces with --paths <dir>,<dir>.');
         }
-        else if (apply) {
-            say(`Split into ${answer.pieces.length}, and the rule that named it rewritten one per directory.`);
-        }
-        else {
+        else if (!apply) {
             say(`Would write ${answer.pieces.map((piece) => piece.workPath).join(', ')}. Pass --force to carry it out.`);
         }
         if (claim) {
@@ -338,11 +501,16 @@ const splitStandIn = (options) => tslib_1.__awaiter(void 0, void 0, void 0, func
             say('Name them in the day review, or re-run with --claim <dir> to give them a directory.');
         }
     }
+    if (apply && answer.pieces.length) {
+        const queued = yield (0, timetrack_1.timetrackApplyStandInSplit)(request);
+        return printedQueued({ queued, what: `split ${standIn.name} into ${answer.pieces.length}`, json });
+    }
     return printed(answer, json);
 });
 const USAGE = `ethlete-agents timetrack — ask the running Timetrack app about Jira
 
 The app holds this machine's Jira credentials, so no repository needs a token of its own.
+Every write waits in the app until the user approves it there, and prints an approval id.
 
   timetrack status              Whether the app is reachable, and which projects it holds
   timetrack instance            The instance's own levels and its branch-subject candidates
@@ -361,10 +529,23 @@ The app holds this machine's Jira credentials, so no repository needs a token of
                                 Delete one placeholder, and the rule that named it
   timetrack standins --rename <id> --name <text>
                                 Give one placeholder another name, keeping its days and its rules
+  timetrack standins --merge <id> --into <id>
+                                Fold one open placeholder into another, with its days and its rules
   timetrack standins --split <id> [--repo <dir>] [--paths <dir>,<dir>] [--claim <dir>] [--author <email>]
                                 [--force]
                                 Cut one that covered a whole checkout into one per directory
+  timetrack worklogs [from] [to]
+                                The account's own Tempo worklogs per day (default: the last 7 days)
+  timetrack calendar [from] [to]
+                                The watched calendars' events per day (default: the last 7 days)
+  timetrack sync <YYYY-MM-DD>   What a Tempo sync of the day would write, as the Sync page plans it
+  timetrack sync <YYYY-MM-DD> --write --plan <hash>
+                                Write that plan to Tempo, once the user confirmed its rows
+  timetrack worklog --delete <id> --day <YYYY-MM-DD>
+                                Delete one of the account's own Tempo worklogs, once the user asked for it
   timetrack naming [YYYY-MM-DD] Which checkouts the day offers a name for, and why the rest do not
+  timetrack resync [path…]      Read the agent session logs of checkouts again, after they got a link
+  timetrack approval <id>       Where a queued write stands, and what it answered once approved
 
 Options for search
   --project <KEY>     Search this project instead of the picked ones
@@ -389,6 +570,14 @@ Options for day
   --out <path>        Write the raw answer to a new file, readable by you alone
   --overwrite         Replace the file --out names, which is refused otherwise
 
+Options for resync
+  --replace           Overwrite what the store holds for those sessions, after a parser fix
+
+Options for sync
+  --write             Queue the write of the plan. Refused without --plan; the app refuses it on
+                      approval when the plan changed since
+  --plan <hash>       The plan hash the read printed, for the rows the user confirmed
+
 Options for edit — pass exactly one change
   --day <YYYY-MM-DD>  The day the row is on (default: today)
   --from <date> --to <date>
@@ -411,7 +600,7 @@ Options everywhere
  * one per checkout.
  */
 const timetrackCommand = (options) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-    var _a;
+    var _a, _b, _c;
     const { root, argv } = options;
     const [subcommand, value] = positionalArgs(argv);
     const json = argv.includes('--json');
@@ -450,7 +639,7 @@ const timetrackCommand = (options) => tslib_1.__awaiter(void 0, void 0, void 0,
             text: value,
             projectKey: flagValue(argv, '--project'),
             assignedToMe: argv.includes('--mine'),
-            limit: numberFlag(argv, '--limit'),
+            limit: countFlag(argv, '--limit'),
         });
         if (!json) {
             if (issues.length === 0)
@@ -460,7 +649,7 @@ const timetrackCommand = (options) => tslib_1.__awaiter(void 0, void 0, void 0,
         return printed(issues, json);
     }
     if (subcommand === 'project') {
-        const found = yield (0, timetrack_1.timetrackRepoProject)(value !== null && value !== void 0 ? value : root);
+        const found = yield (0, timetrack_1.timetrackRepoProject)((0, path_1.resolve)(root, value !== null && value !== void 0 ? value : '.'));
         if (!json) {
             const where = found.inherited ? ' (from a directory above it)' : '';
             if (found.private)
@@ -479,7 +668,7 @@ const timetrackCommand = (options) => tslib_1.__awaiter(void 0, void 0, void 0,
         const summary = flagValue(argv, '--summary');
         if (!summary)
             throw new Error('Pass --summary "…".');
-        const issue = yield (0, timetrack_1.timetrackCreateIssue)({
+        const queued = yield (0, timetrack_1.timetrackCreateIssue)({
             summary,
             description: flagValue(argv, '--description'),
             projectKey: flagValue(argv, '--project'),
@@ -487,9 +676,7 @@ const timetrackCommand = (options) => tslib_1.__awaiter(void 0, void 0, void 0,
             parentKey: flagValue(argv, '--parent'),
             subject: flagValue(argv, '--subject'),
         });
-        if (!json)
-            say(`${issue.key}  ${summary}`);
-        return printed(issue, json);
+        return printedQueued({ queued, what: `file the issue ${summary}`, json });
     }
     if (subcommand === 'log') {
         const issueKey = flagValue(argv, '--issue');
@@ -498,26 +685,27 @@ const timetrackCommand = (options) => tslib_1.__awaiter(void 0, void 0, void 0,
             throw new Error('Pass --issue <KEY>.');
         if (!minutes || minutes <= 0)
             throw new Error('Pass --minutes <n> above zero.');
-        const worklog = yield (0, timetrack_1.timetrackAddWorklog)({
+        const queued = yield (0, timetrack_1.timetrackAddWorklog)({
             issueKey,
             description: flagValue(argv, '--description'),
             fromMs: instantFlag(argv),
             durationMs: Math.round(minutes * 60000),
         });
-        if (!json) {
-            say(`${worklog.issueKey}  ${minutes}m on ${worklog.day}`);
-            say('It is a row on the day, not a Tempo entry — review the day in Timetrack, then sync it.');
-        }
-        return printed(worklog, json);
+        if (!json)
+            say('Once approved it is a row on the day, not a Tempo entry — the day still needs a sync.');
+        return printedQueued({ queued, what: `a ${minutes}m row for ${issueKey}`, json });
     }
     if (subcommand === 'day') {
         const day = value !== null && value !== void 0 ? value : today();
         if (!DAY.test(day))
             throw new Error(`Pass a day as YYYY-MM-DD, not ${day}.`);
         const found = yield (0, timetrack_1.timetrackDayEvents)(day);
-        const out = flagValue(argv, '--out');
-        if (out) {
+        const outFlag = flagValue(argv, '--out');
+        if (outFlag) {
+            const out = (0, path_1.resolve)(root, outFlag);
             writeExport({ path: out, data: JSON.stringify(found), overwrite: argv.includes('--overwrite') });
+            if (json)
+                return printed({ day: found.day, events: found.events.length, out }, json);
             say(`${found.day}  ${found.events.length} events written to ${out}, readable by you alone`);
             say('It holds the day as it was observed: window titles, paths and messages. Delete it when you are done.');
             return 0;
@@ -548,13 +736,8 @@ const timetrackCommand = (options) => tslib_1.__awaiter(void 0, void 0, void 0,
             throw new Error('Pass the row id to edit, as `timetrack rows` prints it.');
         if (!DAY.test(day))
             throw new Error(`Pass a day as YYYY-MM-DD, not ${day}.`);
-        const edited = yield (0, timetrack_1.timetrackEditDay)({ day, edits: [editOf({ argv, rowId: value })] });
-        if (!json) {
-            say(`${edited.day}  ${edited.applied} of 1 edit landed`);
-            edited.rows.forEach((row) => say(`  ${rowLine(row)}`));
-            edited.warnings.forEach((warning) => say(`  ! ${warning.kind}: ${warning.detail}`));
-        }
-        return printed(edited, json);
+        const queued = yield (0, timetrack_1.timetrackEditDay)({ day, edits: [editOf({ argv, rowId: value })] });
+        return printedQueued({ queued, what: `an edit of row ${value} on ${day}`, json });
     }
     if (subcommand === 'rules') {
         const rules = yield (0, timetrack_1.timetrackRules)();
@@ -567,8 +750,90 @@ const timetrackCommand = (options) => tslib_1.__awaiter(void 0, void 0, void 0,
         }
         return printed(rules, json);
     }
+    if (subcommand === 'resync') {
+        const named = positionalArgs(argv).slice(1);
+        const paths = (named.length ? named : ['.']).map((path) => (0, path_1.resolve)(root, path));
+        const replace = argv.includes('--replace');
+        const queued = yield (0, timetrack_1.timetrackResyncAgentSessions)(paths, { replace });
+        const how = replace ? ', replacing what it stored for them' : '';
+        return printedQueued({ queued, what: `read the agent sessions of ${paths.join(', ')} again${how}`, json });
+    }
+    if (subcommand === 'worklogs') {
+        const to = (_b = positionalArgs(argv)[2]) !== null && _b !== void 0 ? _b : today();
+        const from = value !== null && value !== void 0 ? value : shiftDay(to, -6);
+        if (!DAY.test(from))
+            throw new Error(`Pass a day as YYYY-MM-DD, not ${from}.`);
+        if (!DAY.test(to))
+            throw new Error(`Pass a day as YYYY-MM-DD, not ${to}.`);
+        const found = yield (0, timetrack_1.timetrackTempoWorklogs)({ from, to });
+        if (!json) {
+            const total = found.worklogs.reduce((sum, worklog) => sum + worklog.durationMs, 0);
+            say(`${found.from} … ${found.to}  ${found.worklogs.length} worklog(s), ${hours(total)}`);
+            tempoDayLines(found.worklogs).forEach((line) => say(`  ${line}`));
+        }
+        return printed(found, json);
+    }
+    if (subcommand === 'worklog') {
+        if (argv.includes('--help')) {
+            say(USAGE);
+            return 0;
+        }
+        const worklogId = flagValue(argv, '--delete');
+        const day = flagValue(argv, '--day');
+        if (!worklogId || !/^\d+$/.test(worklogId))
+            throw new Error('Pass the Tempo worklog id to delete with --delete <id>.');
+        if (!day || !DAY.test(day))
+            throw new Error('Pass the day the worklog is on with --day <YYYY-MM-DD>.');
+        const queued = yield (0, timetrack_1.timetrackTempoDelete)({ day, worklogId });
+        return printedQueued({ queued, what: `delete Tempo worklog ${worklogId} on ${day}`, json });
+    }
+    if (subcommand === 'sync') {
+        if (!value || !DAY.test(value))
+            throw new Error('Pass the day to sync as YYYY-MM-DD.');
+        const planHash = flagValue(argv, '--plan');
+        const write = argv.includes('--write');
+        if (write && !planHash) {
+            say(`A write names the plan the user confirmed. Read it with \`timetrack sync ${value}\`, show the rows,`);
+            say('and pass the hash it prints with --plan once they agree.');
+            return 1;
+        }
+        if (planHash && !write) {
+            say('--plan only means something with --write. Nothing was written.');
+            return 1;
+        }
+        if (write && planHash) {
+            const queued = yield (0, timetrack_1.timetrackTempoSyncWrite)({ day: value, planHash });
+            if (!json)
+                say('The app checks the plan again on approval, and refuses it if the day changed since.');
+            return printedQueued({ queued, what: `write plan ${planHash} of ${value} to Tempo`, json });
+        }
+        const found = yield (0, timetrack_1.timetrackTempoSync)(value);
+        if (!json) {
+            syncPlanLines(found).forEach(say);
+            if (found.writes.length) {
+                say(`Once the user has confirmed these rows: timetrack sync ${found.day} --write --plan ${found.planHash}`);
+            }
+        }
+        return printed(found, json);
+    }
+    if (subcommand === 'calendar') {
+        const to = (_c = positionalArgs(argv)[2]) !== null && _c !== void 0 ? _c : today();
+        const from = value !== null && value !== void 0 ? value : shiftDay(to, -6);
+        if (!DAY.test(from))
+            throw new Error(`Pass a day as YYYY-MM-DD, not ${from}.`);
+        if (!DAY.test(to))
+            throw new Error(`Pass a day as YYYY-MM-DD, not ${to}.`);
+        const found = yield (0, timetrack_1.timetrackCalendarEvents)({ from, to });
+        if (!json) {
+            say(`${found.from} … ${found.to}  ${found.events.length} event(s) from ${found.calendarIds.length} calendar(s), ${hours(meetingMs(found.events))} in meetings`);
+            calendarDayLines(found.events).forEach((line) => say(`  ${line}`));
+        }
+        return printed(found, json);
+    }
     if (subcommand === 'naming') {
-        const day = value && DAY.test(value) ? value : today();
+        const day = value !== null && value !== void 0 ? value : today();
+        if (!DAY.test(day))
+            throw new Error(`Pass a day as YYYY-MM-DD, not ${day}.`);
         const naming = yield (0, timetrack_1.timetrackNaming)(day);
         if (!json) {
             say(`${day}   tempo ${naming.tempoReady ? 'configured' : 'not configured'}`);
@@ -582,6 +847,15 @@ const timetrackCommand = (options) => tslib_1.__awaiter(void 0, void 0, void 0,
         }
         return printed(naming, json);
     }
+    if (subcommand === 'approval') {
+        if (!value)
+            throw new Error('Pass the approval id a write printed, e.g. `timetrack approval <id>`.');
+        const found = yield (0, timetrack_1.timetrackApprovalStatus)(value);
+        if (!json)
+            approvalLines(found).forEach(say);
+        printed(found, json);
+        return approvalExitCode(found);
+    }
     if (subcommand === 'standins') {
         const split = flagValue(argv, '--split');
         if (split)
@@ -593,10 +867,18 @@ const timetrackCommand = (options) => tslib_1.__awaiter(void 0, void 0, void 0,
             return 1;
         }
         if (rename && name) {
-            const renamed = yield (0, timetrack_1.timetrackRenameStandIn)({ id: rename, name });
-            if (!json)
-                say(`Renamed ${rename} to ${name}.`);
-            return printed(renamed, json);
+            const queued = yield (0, timetrack_1.timetrackRenameStandIn)({ id: rename, name });
+            return printedQueued({ queued, what: `rename ${rename} to ${name}`, json });
+        }
+        const merge = flagValue(argv, '--merge');
+        const into = flagValue(argv, '--into');
+        if (merge && !into) {
+            say(`A merge needs the placeholder it goes into. Pass --into <id> with --merge ${merge}.`);
+            return 1;
+        }
+        if (merge && into) {
+            const queued = yield (0, timetrack_1.timetrackMergeStandIn)({ id: merge, into });
+            return printedQueued({ queued, what: `merge ${merge} into ${into}`, json });
         }
         const remove = flagValue(argv, '--remove');
         const stranded = remove ? yield strandedDays(remove) : [];
@@ -606,14 +888,16 @@ const timetrackCommand = (options) => tslib_1.__awaiter(void 0, void 0, void 0,
             say('The app reopens a placeholder for today only. Pass --force if that is what you want.');
             return 1;
         }
-        const standIns = remove ? yield (0, timetrack_1.timetrackRemoveStandIn)(remove) : yield (0, timetrack_1.timetrackStandIns)();
+        if (remove) {
+            const queued = yield (0, timetrack_1.timetrackRemoveStandIn)(remove);
+            return printedQueued({ queued, what: `delete ${remove} and the rule that named it`, json });
+        }
+        const standIns = yield (0, timetrack_1.timetrackStandIns)();
         const rules = json ? [] : (yield (0, timetrack_1.timetrackRules)()).attributionRules;
         const open = standIns
             .filter((standIn) => standIn.state === 'open')
             .sort((left, right) => left.createdAtMs - right.createdAtMs);
         if (!json) {
-            if (remove)
-                say(`Deleted ${remove}, and the rule that named it.`);
             say(`${open.length} open, ${standIns.length - open.length} resolved`);
             open.forEach((standIn) => say(`  ${describeStandIn({ standIn, rules })}`));
             if (open.length)