ticketlens 0.21.5 → 0.21.7

package/README.md

@@ -403,7 +403,9 @@ Every note is scanned before saving — anything shaped like a real secret (API
 
 **Team sync:** on a Team plan with Recall enabled for your account (owner-managed, per-tier or per-client), notes also sync to your team's shared pool — `note add` pushes in the background, `recall` pulls the team's notes (cached 4h) before searching. A team manager reviews and verifies incoming notes at `console/admin/recall` before they're marked trusted. Without Team Recall entitlement, everything stays on your machine — no network call.
 
-**Offline resilience:** if a team push fails for a transient reason (network error, timeout, or a 5xx from the backend), the note stays safely in your local vault and is queued for retry — nothing is lost. The queue flushes automatically in the background (at most once every 15 minutes, whenever `recall` or `note add` next talks to the network), or on demand with `ticketlens recall sync`. A session-expired (401) or not-entitled (403) push is never queued — those need you to act (`ticketlens login`, or an owner grant), not a retry. Queued entries expire after 30 days and are capped at 200; switching accounts never flushes a note under the wrong login.
+**Offline resilience:** if a team push fails for a transient reason (network error, timeout, or a 5xx from the backend), the note stays safely in your local vault and is queued for retry — nothing is lost. The queue flushes automatically in the background (at most once every 15 minutes) before every command, not just `recall`/`note add` — a short 4s timeout on that check means it never stalls an unrelated command — or on demand with `ticketlens recall sync`. A session-expired (401) or not-entitled (403) push is never queued — those need you to act (`ticketlens login`, or an owner grant), not a retry. Queued entries expire after 30 days and are capped at 200; switching accounts never flushes a note under the wrong login.
+
+**Removing a note:** `ticketlens note delete --id="..." [--ticket=KEY]` removes a note from your local vault. Local only — if it was already pushed to a team, teammates who pulled it keep their copy; deleting it there too is a manager action from the Console (Admin > Recall).
 
 `note add`'s save confirmation and `recall`'s search results are styled by default in a terminal; add `--plain` to either for bare, pipe-safe output. `recall` always shows each note's file ID (e.g. `[1784135399545-fe01c4.md]`) so you can open it directly (`cat ~/.ticketlens/recall/<PREFIX>/<id>`), or pass `--full` to print the full body content inline instead.
 
@@ -678,6 +680,7 @@ ticketlens history <TICKET-KEY>               # Show urgency timeline for a tick
 
 # ── Recall ────────────────────────────────────────────────────────────────────
 echo "note body" | ticketlens note add --title="..." --ticket=CNV1-2 --tags=a,b  # Save a note [Pro]
+ticketlens note delete --id="..." --ticket=CNV1-2  # Remove a note from your local vault [Pro]
 ticketlens recall CNV1-2                      # Search saved notes by ticket key [Pro]
 ticketlens recall "retry backoff"             # Free-text search across all notes [Pro]
 ticketlens recall sync                        # Retry any notes stuck in the local queue [Pro]
@@ -758,6 +761,7 @@ ticketlens triage --stale=3              # Custom stale threshold (default is 5)
 ticketlens triage --digest               # POST scored triage results to digest endpoint
 ticketlens schedule                      # Set up a scheduled daily digest
 ticketlens note add --title="..."        # Save a Recall note (body from stdin)
+ticketlens note delete --id="..."        # Remove a note from your local vault
 ticketlens recall <query|TICKET-KEY>     # Search your saved Recall notes
 ticketlens recall sync                   # Retry any notes stuck in the local queue
 ticketlens activate YOUR-LICENSE-KEY     # Activate Pro license

package/bin/ticketlens.mjs

@@ -37,6 +37,7 @@ import { checkForUpdate, getUpdateHint } from '../skills/jtb/scripts/lib/update-
 import { incrementInvocation, incrementCommand } from '../skills/jtb/scripts/lib/activity-counter.mjs';
 import { DEFAULT_CONFIG_DIR } from '../skills/jtb/scripts/lib/config.mjs';
 import { checkTeamJiraConfigUpdate } from '../skills/jtb/scripts/lib/team-jira-sync.mjs';
+import { maybeAutoFlush } from '../skills/jtb/scripts/lib/recall-queue.mjs';
 
 const TRACKED_COMMANDS = new Set([
   'triage', 'fetch', 'get', 'compliance', 'review', 'standup',
@@ -60,6 +61,26 @@ revalidateIfStale();
 // Fire-and-forget: refresh the cached latest npm version once per 24h
 checkForUpdate();
 
+// Best-effort: retry any Recall notes still queued from a prior failed push —
+// on every command now, not just note add/recall, so a backlog from a burst
+// of transient failures doesn't just sit until the user happens to run one
+// of those two again. Cheap no-op when the queue is empty (one local file
+// read); maybeAutoFlush's own cooldown still protects a down backend from
+// being hit by every single command.
+try {
+  const cliToken = readCliToken(DEFAULT_CONFIG_DIR);
+  if (cliToken) {
+    // Short timeout — this runs before every command, unrelated to Recall or
+    // not, so it must never be the reason an unrelated command feels slow.
+    const result = await maybeAutoFlush({ cliToken, configDir: DEFAULT_CONFIG_DIR, timeoutMs: 4000 });
+    if (result?.flushed) {
+      process.stderr.write(`  ✔ Synced ${result.flushed} pending Recall note${result.flushed === 1 ? '' : 's'}.\n`);
+    }
+  }
+} catch {
+  // Never let a background sync check break the actual command.
+}
+
 // Show a one-line update hint on stderr after the command exits (never blocks stdout)
 process.on('exit', () => {
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.21.5",
+  "version": "0.21.7",
   "description": "Jira CLI for developers — fetch ticket context, triage your queue, and stop tab-switching. Zero dependencies, all local.",
   "type": "module",
   "bin": {

package/skills/jtb/scripts/lib/help.mjs

@@ -46,6 +46,7 @@ export function printHelp({ stream = process.stdout } = {}) {
     `    ${s.brand('ticketlens')} history ${s.dim('<TICKET-KEY>')}       Urgency timeline for a ticket  ${s.dim('[Pro]')}`,
     `    ${s.brand('ticketlens')} stats ${s.dim('[options]')}            Personal response-time metrics from local history`,
     `    ${s.brand('ticketlens')} note add ${s.dim('--title=... [--ticket=KEY]')}  Save a Recall note  ${s.dim('[Pro]')}`,
+    `    ${s.brand('ticketlens')} note delete ${s.dim('--id=... [--ticket=KEY]')}  Remove a note from your local vault  ${s.dim('[Pro]')}`,
     `    ${s.brand('ticketlens')} recall ${s.dim('<query|TICKET-KEY>')}   Search your saved Recall notes  ${s.dim('[Pro]')}`,
     '',
     `    ${s.brand('ticketlens')} delete ${s.dim('<PROFILE-NAME>')}       Remove a profile`,

package/skills/jtb/scripts/lib/recall-queue.mjs

@@ -141,6 +141,7 @@ export async function flushQueue({
   isRetryableFailureFn = isRetryableFailure,
   warn = () => {},
   now = () => Date.now(),
+  timeoutMs,
 } = {}) {
   const nowMs = now();
   const currentHash = hashToken(cliToken);
@@ -154,7 +155,9 @@ export async function flushQueue({
       continue;
     }
 
-    const result = await pushNoteFn(entry.notePayload, { cliToken, configDir, warn });
+    const result = await pushNoteFn(entry.notePayload, {
+      cliToken, configDir, warn, ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+    });
     if (result.ok) {
       flushed++;
       continue;
@@ -191,36 +194,52 @@ function writeLastFlushAttemptAt(configDir, isoTimestamp) {
 }
 
 /**
- * Time-gated background flush, attempted from the CLI's existing
- * Recall-touching entry points (note add's push, recall's pull) rather than
- * on every invocation — a no-op unless the queue is non-empty AND at least
- * AUTO_FLUSH_INTERVAL_MS has passed since the last attempt. The attempt
- * timestamp is recorded even on failure, so a down backend can't be hammered
- * once per command within the window.
+ * Time-gated background flush. Called from every command's entry point
+ * (bin/ticketlens.mjs), not just Recall-specific ones — a note added during
+ * a burst of failures (e.g. a debugging session) would otherwise sit queued
+ * until the user happens to run `note add`/`recall` again, or runs
+ * `recall sync` by hand. A no-op unless the queue is non-empty AND at least
+ * AUTO_FLUSH_INTERVAL_MS has passed since the last attempt — the interval is
+ * a single global cooldown, not per-entry, so a burst of failures in one
+ * short window still only gets one automatic retry pass, by design: this
+ * runs on every command now, so the next opportunity is never far away, and
+ * the cooldown exists specifically to stop a down backend from being hit by
+ * every single command in the meantime. The attempt timestamp is recorded
+ * even on failure, so a down backend can't be hammered once per command
+ * within the window.
  *
  * @param {object}   opts
  * @param {string}   opts.cliToken
  * @param {string}   [opts.configDir]
  * @param {() => number} [opts.now]
  * @param {Function} [opts.flushQueueFn]
+ * @param {number}   [opts.timeoutMs] - per-request timeout, passed through to
+ *   pushNote. Callers running this unconditionally on every command (as
+ *   opposed to an explicit `recall sync`) should pass something short — this
+ *   must feel instant, not stall an unrelated command behind a slow network.
+ * @returns {Promise<{flushed: number, remaining: number}|null>} null if skipped
+ *   (empty queue or still cooling down) — distinguishes "nothing to report"
+ *   from "attempted, flushed 0" for a caller that wants to print a summary.
  */
 export async function maybeAutoFlush({
   cliToken,
   configDir = DEFAULT_CONFIG_DIR,
   now = () => Date.now(),
   flushQueueFn = flushQueue,
+  timeoutMs,
 } = {}) {
-  if (readQueue(configDir).length === 0) return;
+  if (readQueue(configDir).length === 0) return null;
 
   const lastAttemptAt = readLastFlushAttemptAt(configDir);
   const nowMs = now();
-  if (lastAttemptAt && nowMs - new Date(lastAttemptAt).getTime() < AUTO_FLUSH_INTERVAL_MS) return;
+  if (lastAttemptAt && nowMs - new Date(lastAttemptAt).getTime() < AUTO_FLUSH_INTERVAL_MS) return null;
 
   try {
-    await flushQueueFn({ cliToken, configDir, now });
+    return await flushQueueFn({ cliToken, configDir, now, ...(timeoutMs !== undefined ? { timeoutMs } : {}) });
   } catch {
     // A down backend or a thrown network error must never crash the command
     // that opportunistically triggered this background attempt.
+    return null;
   } finally {
     writeLastFlushAttemptAt(configDir, new Date(nowMs).toISOString());
   }