ticketlens 0.38.14 → 0.38.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.38.14",
+  "version": "0.38.16",
   "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/hooks/recall-nudge-lib.mjs

@@ -1,17 +1,23 @@
 /**
- * Shared helpers for the Recall nudge hooks (recall-nudge-post-tool.mjs,
- * recall-nudge-stop.mjs). Both read the same Claude Code hook stdin JSON
- * and the same session transcript — kept in one place so the detection
- * logic can't drift between the two hooks.
+ * Shared helpers for the Recall nudge Stop hook (recall-nudge-stop.mjs).
+ * The retired PostToolUse mid-session nudge (recall-nudge-post-tool.mjs)
+ * used to share this module too — removed because it only ever matched
+ * Bash tool calls and went silently inert once ticket work moved to MCP
+ * tools, which SKILL.md tells Claude to prefer over Bash whenever available.
  */
 
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import crypto from 'node:crypto';
 
 export const TICKET_KEY_RE = /\b[A-Z][A-Z0-9]{1,9}-\d+\b/;
 export const RECALL_FLAG_RE = /🔖\s*Recall-flag:/;
 export const NOTE_ADD_RE = /\bticketlens\s+note\s+add\b|\/jtb\s+note\b/;
+// Matches the MCP tool_use name Claude Code gives an MCP server's tool call
+// (mcp__<server-alias>__<tool-name>) — the server alias is whatever the user
+// named it in their own .mcp.json, so only the tool-name suffix is fixed.
+export const NOTE_ADD_MCP_RE = /^mcp__.+__recall_add$/;
 
 export function readStdinJson() {
   const raw = fs.readFileSync(0, 'utf8');
@@ -40,6 +46,59 @@ export function writeState(sessionId, state) {
   } catch { /* best-effort — a lost nudge counter is not worth failing the hook over */ }
 }
 
+// Two hours — how long a real capture in one directory counts as "recent
+// enough" to skip the Stop hook's nag, even from a brand-new session_id.
+export const CAPTURE_FRESHNESS_MS = 2 * 60 * 60 * 1000;
+
+/**
+ * Cross-session capture marker, keyed by a hash of `cwd` rather than
+ * `session_id`. The per-session_id state file (readState/writeState above)
+ * cannot answer "was something captured recently" once a compaction/resume
+ * event rolls the session_id over — that starts both a blank dedup state
+ * AND a blank transcript file, so a genuine earlier capture becomes
+ * invisible to scanTranscript(). This marker survives that boundary because
+ * it's keyed by the (stable) working directory instead.
+ *
+ * Lives in a user-private, mode-0700 subdirectory rather than directly in
+ * (often world-writable, on Linux) os.tmpdir() — unlike statePath()'s
+ * session_id (an unguessable UUID), a hash of `cwd` is derived from a much
+ * smaller, guessable input space (common project directory names), so a
+ * predictable path directly in shared tmp could be pre-planted by another
+ * local user on a shared box.
+ */
+function privateTmpDir() {
+  const owner = typeof process.getuid === 'function' ? process.getuid() : os.userInfo().username;
+  const dir = path.join(os.tmpdir(), `ticketlens-recall-nudge-${owner}`);
+  try {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  } catch { /* best-effort — a write into it below will just fail safely too */ }
+  return dir;
+}
+
+export function lastCapturePath(cwd) {
+  const hash = crypto.createHash('sha256').update(cwd || 'unknown').digest('hex').slice(0, 16);
+  return path.join(privateTmpDir(), `lastcapture-${hash}.json`);
+}
+
+export function readLastCaptureAt(cwd) {
+  try {
+    return JSON.parse(fs.readFileSync(lastCapturePath(cwd), 'utf8')).lastCaptureAt ?? 0;
+  } catch {
+    return 0;
+  }
+}
+
+export function writeLastCaptureAt(cwd, timestamp) {
+  try {
+    fs.writeFileSync(lastCapturePath(cwd), JSON.stringify({ lastCaptureAt: timestamp }));
+  } catch { /* best-effort — losing this marker only costs one extra nag next rollover */ }
+}
+
+export function hasRecentCapture(cwd, now = Date.now()) {
+  const lastCaptureAt = readLastCaptureAt(cwd);
+  return lastCaptureAt > 0 && (now - lastCaptureAt) < CAPTURE_FRESHNESS_MS;
+}
+
 /**
  * Reads the transcript (JSONL) and returns simple booleans about what
  * happened this session. Best-effort: any read/parse failure returns all
@@ -54,7 +113,11 @@ export function writeState(sessionId, state) {
  * Claude just flagged something every time) and sawNoteAdd gets stuck true
  * (silently disabling the Stop-hook check, since it thinks a note was
  * already added). Only count a real assistant-authored text block for the
- * flag, and only a real executed Bash command for note-add.
+ * flag, and only a real executed note-add — either the CLI (`ticketlens
+ * note add`/`/jtb note` via Bash) or the ticketlens MCP server's recall_add
+ * tool — for note-add. Missing the MCP path here was a real bug: it made
+ * the Stop hook nudge even after a note was genuinely captured via MCP,
+ * since only the Bash/CLI form was ever recognized.
  */
 export function scanTranscript(transcriptPath) {
   const result = { sawTicketKey: false, sawRecallFlag: false, sawNoteAdd: false };
@@ -86,8 +149,10 @@ export function scanTranscript(transcriptPath) {
       if (block.type === 'text' && RECALL_FLAG_RE.test(block.text ?? '')) {
         result.sawRecallFlag = true;
       }
-      if (block.type === 'tool_use' && block.name === 'Bash' && NOTE_ADD_RE.test(block.input?.command ?? '')) {
-        result.sawNoteAdd = true;
+      if (block.type === 'tool_use') {
+        const isCliNoteAdd = block.name === 'Bash' && NOTE_ADD_RE.test(block.input?.command ?? '');
+        const isMcpNoteAdd = NOTE_ADD_MCP_RE.test(block.name ?? '');
+        if (isCliNoteAdd || isMcpNoteAdd) result.sawNoteAdd = true;
       }
     }
   }

package/skills/jtb/hooks/recall-nudge-stop.mjs

@@ -10,25 +10,41 @@
  *      — the weaker "did anything ever get considered?" catch.
  * Anything else (no ticket work at all, or a note was already added) exits
  * clean — this must never be the reason a session can't end.
+ *
+ * The per-session_id "asked once" state (readState/writeState) cannot
+ * survive a compaction/resume event — that hands this hook a brand-new
+ * session_id, a blank dedup state, AND a blank transcript file, so a real
+ * earlier capture becomes invisible. The cross-session lastCapture marker
+ * (keyed by cwd, not session_id) is what actually bridges that boundary.
  */
 
-import { readStdinJson, readState, writeState, scanTranscript } from './recall-nudge-lib.mjs';
+import { readStdinJson, readState, writeState, scanTranscript, hasRecentCapture, writeLastCaptureAt } from './recall-nudge-lib.mjs';
 
 const input = readStdinJson();
 const sessionId = input?.session_id;
 const transcriptPath = input?.transcript_path;
+const cwd = input?.cwd ?? process.cwd();
 
 if (!sessionId || !transcriptPath) process.exit(0);
 
+const { sawTicketKey, sawRecallFlag, sawNoteAdd } = scanTranscript(transcriptPath);
+
+// Refreshed on every check, independent of the once-per-session gate below —
+// a capture that happens AFTER this session already nagged once must still
+// update the marker, or a later session_id rollover would find it stale.
+if (sawNoteAdd) writeLastCaptureAt(cwd, Date.now());
+
 const state = readState(sessionId);
 if (state.stopChecked) process.exit(0); // already asked once this session — respect the answer
 
-const { sawTicketKey, sawRecallFlag, sawNoteAdd } = scanTranscript(transcriptPath);
-
 if (!sawTicketKey || sawNoteAdd) {
   process.exit(0); // no ticket work, or already captured — nothing to force
 }
 
+if (hasRecentCapture(cwd)) {
+  process.exit(0); // a real capture landed recently in this same directory, just under a different session_id
+}
+
 state.stopChecked = true;
 writeState(sessionId, state);
 

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

@@ -471,10 +471,11 @@ export function printProfilesHelp({ stream = process.stdout } = {}) {
     '',
     `  ${s.bold('SUBCOMMANDS')}`,
     '',
-    `    ${s.brand('set-team')} ${s.dim('<profile> <team name>')}`,
+    `    ${s.brand('set-team')} ${s.dim('<profile> [team name]')}`,
     `        Route this profile's Recall notes to a specific Console team —`,
-    `        for accounts that belong to more than one team. Validated against`,
-    `        teams synced by ${s.cyan('ticketlens login')}/${s.cyan('ticketlens sync')}, but never blocked by a stale list.`,
+    `        for accounts that belong to more than one team. Omit the team name`,
+    `        to pick one interactively from your synced teams. Stored by id,`,
+    `        refreshed by ${s.cyan('ticketlens login')}/${s.cyan('ticketlens sync')}.`,
     '',
     `  ${s.bold('OPTIONS')}`,
     '',

package/skills/jtb/scripts/lib/hooks-setup.mjs

@@ -1,8 +1,12 @@
 /**
- * Installs the Recall nudge hooks (recall-nudge-post-tool.mjs,
- * recall-nudge-stop.mjs) into any detected Claude Code settings.json —
- * run from postinstall.mjs on every install/update so a user never has to
- * wire this by hand. Idempotent: safe to run on every `npm install`.
+ * Installs the Recall nudge Stop hook (recall-nudge-stop.mjs) into any
+ * detected Claude Code settings.json — run from postinstall.mjs on every
+ * install/update so a user never has to wire this by hand. Idempotent: safe
+ * to run on every `npm install`. Also cleans up the retired PostToolUse
+ * nudge (recall-nudge-post-tool.mjs) from any settings.json that still has
+ * it from a prior install — it only ever matched Bash tool calls, so it
+ * went silently inert once ticket work moved to MCP tools, and was removed
+ * rather than left as dead config.
  *
  * Never touches an existing settings.json's other content, and never
  * throws — a malformed or unreadable settings.json is skipped, not
@@ -16,12 +20,11 @@ import { homedir } from 'node:os';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const HOOKS_DIR = join(__dirname, '..', '..', 'hooks');
-const POST_TOOL_SCRIPT = join(HOOKS_DIR, 'recall-nudge-post-tool.mjs');
-const STOP_SCRIPT       = join(HOOKS_DIR, 'recall-nudge-stop.mjs');
+const STOP_SCRIPT = join(HOOKS_DIR, 'recall-nudge-stop.mjs');
 
-// Distinctive substring used to find/replace our own entries on re-install —
+// Distinctive substrings used to find our own entries on re-install/cleanup —
 // never matches anything a user could plausibly have written by hand.
-const MARKER = 'recall-nudge-post-tool.mjs';
+const RETIRED_POST_TOOL_MARKER = 'recall-nudge-post-tool.mjs';
 const STOP_MARKER = 'recall-nudge-stop.mjs';
 
 const CLAUDE_DIRS = [
@@ -42,6 +45,11 @@ function makeHookEntry(scriptPath, matcher) {
   };
 }
 
+// Both functions below locate our own hook by a marker substring inside a
+// list entry's `hooks` array, but must never drop an unrelated hook a user
+// happens to have colocated in that same array entry (e.g. sharing our
+// matcher) — only our own matching inner hook is ever added/replaced/removed.
+
 function upsertHookEntry(list, marker, entry) {
   const idx = list.findIndex(h =>
     (h.hooks || []).some(inner => typeof inner.command === 'string' && inner.command.includes(marker)),
@@ -50,12 +58,32 @@ function upsertHookEntry(list, marker, entry) {
     list.push(entry);
     return 'added';
   }
-  if (JSON.stringify(list[idx]) === JSON.stringify(entry)) return 'unchanged';
-  list[idx] = entry;
+  const ownInner = entry.hooks[0]; // makeHookEntry always builds a single-command entry
+  const otherHooks = list[idx].hooks.filter(inner => !(typeof inner.command === 'string' && inner.command.includes(marker)));
+  // Our hook was the only thing in this entry — safe to fully replace
+  // (also picks up a matcher change, if any). Otherwise preserve the
+  // entry's existing matcher and other hooks, just swap our own inner hook.
+  const merged = otherHooks.length === 0 ? entry : { ...list[idx], hooks: [...otherHooks, ownInner] };
+  if (JSON.stringify(list[idx]) === JSON.stringify(merged)) return 'unchanged';
+  list[idx] = merged;
   return 'updated';
 }
 
-function installInto(settingsPath) {
+function removeHookEntry(list, marker) {
+  const idx = list.findIndex(h =>
+    (h.hooks || []).some(inner => typeof inner.command === 'string' && inner.command.includes(marker)),
+  );
+  if (idx === -1) return 'absent';
+  const remaining = list[idx].hooks.filter(inner => !(typeof inner.command === 'string' && inner.command.includes(marker)));
+  if (remaining.length === 0) {
+    list.splice(idx, 1);
+  } else {
+    list[idx] = { ...list[idx], hooks: remaining };
+  }
+  return 'removed';
+}
+
+export function installInto(settingsPath) {
   let settings = {};
   if (existsSync(settingsPath)) {
     try {
@@ -69,18 +97,14 @@ function installInto(settingsPath) {
   settings.hooks.PostToolUse ??= [];
   settings.hooks.Stop ??= [];
 
-  const postResult = upsertHookEntry(
-    settings.hooks.PostToolUse,
-    MARKER,
-    makeHookEntry(POST_TOOL_SCRIPT, 'Bash'),
-  );
+  const postCleanupResult = removeHookEntry(settings.hooks.PostToolUse, RETIRED_POST_TOOL_MARKER);
   const stopResult = upsertHookEntry(
     settings.hooks.Stop,
     STOP_MARKER,
     makeHookEntry(STOP_SCRIPT, '*'),
   );
 
-  if (postResult === 'unchanged' && stopResult === 'unchanged') {
+  if (postCleanupResult === 'absent' && stopResult === 'unchanged') {
     return { status: 'unchanged' };
   }
 
@@ -89,7 +113,7 @@ function installInto(settingsPath) {
   // Atomic on POSIX — avoids ever leaving settings.json half-written.
   renameSync(tmpPath, settingsPath);
 
-  return { status: 'installed', postResult, stopResult };
+  return { status: 'installed', postCleanupResult, stopResult };
 }
 
 /**

package/skills/jtb/scripts/lib/profile-resolver.mjs

@@ -262,6 +262,22 @@ export function resolveProfile(ticketKey, opts = {}) {
   return null;
 }
 
+/**
+ * Names of every profile whose ticketPrefixes includes `prefix` — used to
+ * cross-check a resolved connection against the project/team key the caller
+ * actually asked for. `ticket_create` has no ticket key to prefix-match
+ * against (unlike every other ticket-write command), so this checks the raw
+ * project/team key directly instead, as a safety net against silently
+ * creating a ticket on the wrong tracker.
+ */
+export function findProfilesByPrefix(prefix, configDir = DEFAULT_CONFIG_DIR) {
+  const config = loadProfiles(configDir);
+  if (!config) return [];
+  return Object.entries(config.profiles)
+    .filter(([, profile]) => profile.ticketPrefixes?.includes(prefix))
+    .map(([name]) => name);
+}
+
 export function resolveConnection(ticketKey, opts = {}) {
   const { env = process.env, configDir = DEFAULT_CONFIG_DIR, profileName, onWarning, onProfileNotFound, cwd } = opts;
 

package/skills/jtb/scripts/lib/ticket-command.mjs

@@ -12,7 +12,7 @@
 import os from 'node:os';
 import { DEFAULT_CONFIG_DIR } from './config.mjs';
 import { isLicensed, showUpgradePrompt } from './license.mjs';
-import { resolveConnection } from './profile-resolver.mjs';
+import { resolveConnection, findProfilesByPrefix } from './profile-resolver.mjs';
 import { resolveAdapter } from './resolve-adapter.mjs';
 import { checkCooldown, recordAction } from './ticket-action-cooldown.mjs';
 import { logAction } from './ticket-action-log.mjs';
@@ -218,15 +218,24 @@ function requireTicketKey(cmdArgs, usage, stream) {
 
 /**
  * `ticketKey` is undefined for ticket_create — there is no existing ticket to
- * prefix-match a connection from, so resolution falls through to --profile
- * or the default profile (resolveConnectionFn already handles a falsy
- * ticketKey by skipping prefix matching, see profile-resolver.mjs).
+ * prefix-match a connection from, so resolution falls through to --profile,
+ * the folder-based `cwd` match, or the default profile (resolveConnectionFn
+ * already handles a falsy ticketKey by skipping prefix matching, see
+ * profile-resolver.mjs). `cwd` is always the running process's own — every
+ * ticket-write command runs synchronously within a single CLI/MCP-server
+ * invocation, so there is never a separate "caller's cwd" to thread through.
+ *
+ * Returns `{ adapter, conn }` (not just the adapter) so callers that need to
+ * cross-check the resolved connection's identity — currently only
+ * `runTicketCreate`'s profile/project mismatch safety net — have it without
+ * re-resolving.
  */
 function resolveTicketAdapter(ticketKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream }) {
   const profileName = parseFlag(cmdArgs, 'profile');
   const conn = resolveConnectionFn(ticketKey, {
     configDir,
     profileName,
+    cwd: process.cwd(),
     onWarning: (msg) => stream.write(`  ⚠ ${msg}\n`),
   });
   if (!conn.baseUrl) {
@@ -235,7 +244,7 @@ function resolveTicketAdapter(ticketKey, cmdArgs, { configDir, resolveConnection
       : `  No connection configured. Run \`ticketlens init\` or pass --profile=NAME.\n`);
     return null;
   }
-  return resolveAdapterFn(conn);
+  return { adapter: resolveAdapterFn(conn), conn };
 }
 
 /**
@@ -272,8 +281,9 @@ export async function runTicketComment(cmdArgs, {
     return { ok: false };
   }
 
-  const adapter = resolveTicketAdapter(ticketKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
-  if (!adapter) return { ok: false };
+  const resolved = resolveTicketAdapter(ticketKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
+  if (!resolved) return { ok: false };
+  const { adapter } = resolved;
   const s = createStyler({ isTTY: stream.isTTY });
 
   // Uploaded BEFORE the comment write so a tracker capable of inline
@@ -330,8 +340,9 @@ export async function runTicketTransitionList(cmdArgs, {
   const ticketKey = requireTicketKey(cmdArgs, usage, stream);
   if (!ticketKey) return { ok: false };
 
-  const adapter = resolveTicketAdapter(ticketKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
-  if (!adapter) return { ok: false };
+  const resolved = resolveTicketAdapter(ticketKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
+  if (!resolved) return { ok: false };
+  const { adapter } = resolved;
 
   try {
     const options = await adapter.getTransitions(ticketKey);
@@ -396,8 +407,9 @@ export async function runTicketTransition(cmdArgs, {
     return { ok: false };
   }
 
-  const adapter = resolveTicketAdapter(ticketKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
-  if (!adapter) return { ok: false };
+  const resolved = resolveTicketAdapter(ticketKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
+  if (!resolved) return { ok: false };
+  const { adapter } = resolved;
 
   try {
     const result = await adapter.transition(ticketKey, target);
@@ -456,8 +468,9 @@ export async function runTicketAssign(cmdArgs, {
     return { ok: false };
   }
 
-  const adapter = resolveTicketAdapter(ticketKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
-  if (!adapter) return { ok: false };
+  const resolved = resolveTicketAdapter(ticketKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
+  if (!resolved) return { ok: false };
+  const { adapter } = resolved;
 
   try {
     const result = await adapter.assignToSelf(ticketKey);
@@ -502,8 +515,9 @@ export async function runTicketDuplicates(cmdArgs, {
     }
   }
 
-  const adapter = resolveTicketAdapter(ticketKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
-  if (!adapter) return { ok: false };
+  const resolved = resolveTicketAdapter(ticketKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
+  if (!resolved) return { ok: false };
+  const { adapter } = resolved;
 
   try {
     // depth: 0 — only the shallow linkedIssues list is needed (for explicit
@@ -581,8 +595,9 @@ export async function runTicketLinkList(cmdArgs, {
   const targetKey = requireTicketKey(cmdArgs.slice(1), usage, stream);
   if (!targetKey) return { ok: false };
 
-  const adapter = resolveTicketAdapter(sourceKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
-  if (!adapter) return { ok: false };
+  const resolved = resolveTicketAdapter(sourceKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
+  if (!resolved) return { ok: false };
+  const { adapter } = resolved;
 
   try {
     const types = await adapter.getLinkTypes();
@@ -658,8 +673,9 @@ export async function runTicketLink(cmdArgs, {
     return { ok: false };
   }
 
-  const adapter = resolveTicketAdapter(sourceKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
-  if (!adapter) return { ok: false };
+  const resolved = resolveTicketAdapter(sourceKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
+  if (!resolved) return { ok: false };
+  const { adapter } = resolved;
 
   if (adapter.type === 'github' && type.toLowerCase() !== 'duplicate') {
     stream.write(`  GitHub only supports linking as a duplicate — no generic link types. Got type "${type}".\n`);
@@ -748,8 +764,9 @@ export async function runTicketUpdate(cmdArgs, {
     return { ok: false };
   }
 
-  const adapter = resolveTicketAdapter(ticketKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
-  if (!adapter) return { ok: false };
+  const resolved = resolveTicketAdapter(ticketKey, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
+  if (!resolved) return { ok: false };
+  const { adapter } = resolved;
 
   if (adapter.type === 'github' && priority !== undefined) {
     stream.write(`  GitHub Issues have no native priority field — cannot update priority on ${ticketKey}. Remove --priority and retry.\n`);
@@ -808,6 +825,7 @@ export async function runTicketCreate(cmdArgs, {
   logActionFn = logAction,
   readMetadataCacheFn = readMetadataCache,
   writeMetadataCacheFn = writeMetadataCache,
+  findProfilesByPrefixFn = findProfilesByPrefix,
   actor = os.userInfo().username,
 } = {}) {
   const usage = 'Usage: ticketlens create --project=KEY --type="Task" --summary="..." [--description="..."] [--profile=NAME]\n';
@@ -824,8 +842,9 @@ export async function runTicketCreate(cmdArgs, {
   const description = parseFlag(cmdArgs, 'description');
   const attachPaths = parseAttachPaths(cmdArgs);
 
-  const adapter = resolveTicketAdapter(undefined, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
-  if (!adapter) return { ok: false };
+  const resolved = resolveTicketAdapter(undefined, cmdArgs, { configDir, resolveConnectionFn, resolveAdapterFn, stream });
+  if (!resolved) return { ok: false };
+  const { adapter, conn } = resolved;
   const s = createStyler({ isTTY: stream.isTTY });
   const attachRefused = refuseGithubAttachments(adapter, attachPaths, stream);
 
@@ -841,6 +860,28 @@ export async function runTicketCreate(cmdArgs, {
     stream.write(`  Note: --type is ignored by ${adapter.type} — issue created without it.\n`);
   }
 
+  // Highest-blast-radius write in the family: no ticket key exists yet to
+  // prefix-match against, so a resolution that quietly lands on the wrong
+  // profile (e.g. an unconfigured cwd falling to the default) fabricates a
+  // real ticket on the wrong tracker before anyone notices. Only refuses
+  // when a DIFFERENT profile is a known, better owner of this exact project
+  // key — a genuinely new, not-yet-registered project proceeds untouched.
+  // Skipped when the caller explicitly passed --profile=NAME: that is
+  // deliberate, informed intent (the same trust resolveProfile() itself
+  // already gives an explicit flag over every other signal), and this guard
+  // must never be a dead end with no way to force a legitimate create through.
+  if (adapter.type !== 'github' && project && conn.profileName && !parseFlag(cmdArgs, 'profile')) {
+    const owningProfiles = findProfilesByPrefixFn(project, configDir);
+    if (owningProfiles.length > 0 && !owningProfiles.includes(conn.profileName)) {
+      stream.write(
+        `  Project "${project}" is registered under profile "${owningProfiles[0]}", not the resolved profile ` +
+        `"${conn.profileName}". Pass --profile=${owningProfiles[0]} to target the right tracker, or ` +
+        `--profile=${conn.profileName} to confirm this is intentional.\n`,
+      );
+      return { ok: false };
+    }
+  }
+
   // JSON-encoded, not naively colon-joined — project/type/summary are free
   // text that can themselves contain ":", which would let two genuinely
   // different tuples collide onto the same cooldown key.

package/skills/jtb/hooks/recall-nudge-post-tool.mjs

@@ -1,52 +0,0 @@
-#!/usr/bin/env node
-/**
- * PostToolUse hook (matcher: Bash) — mid-session Recall nudge.
- *
- * Non-blocking by design: this only prints an advisory reminder to stdout
- * every NUDGE_EVERY ticket-related Bash calls, and only if Claude hasn't
- * self-flagged a Recall-worthy insight (🔖 Recall-flag:) since the last one.
- * Never exits non-zero — a mid-session nudge must never interrupt real work.
- */
-
-import { readStdinJson, statePath, readState, writeState, TICKET_KEY_RE, scanTranscript } from './recall-nudge-lib.mjs';
-
-const NUDGE_EVERY = 8; // ticket-related Bash calls between nudges
-
-const input = readStdinJson();
-const command = input?.tool_input?.command ?? '';
-const sessionId = input?.session_id;
-const transcriptPath = input?.transcript_path;
-
-if (!TICKET_KEY_RE.test(command) || !sessionId) {
-  process.exit(0);
-}
-
-const state = readState(sessionId);
-state.ticketToolCalls = (state.ticketToolCalls ?? 0) + 1;
-
-// If Claude already self-flagged since we last reset, don't nag — reset the
-// counter so the next nudge only fires after another full quiet stretch.
-if (transcriptPath) {
-  const { sawRecallFlag } = scanTranscript(transcriptPath);
-  if (sawRecallFlag) {
-    state.ticketToolCalls = 0;
-    writeState(sessionId, state);
-    process.exit(0);
-  }
-}
-
-if (state.ticketToolCalls >= NUDGE_EVERY) {
-  state.ticketToolCalls = 0;
-  state.lastNudgeAt = Date.now();
-  writeState(sessionId, state);
-  process.stdout.write(
-    'Reminder (not a request for action right now): if something non-obvious was ' +
-    'confirmed in the last stretch of ticket work — a gotcha, a root cause, a ' +
-    'decision with non-obvious rationale — capture it now via `ticketlens note add` ' +
-    'per the jtb skill\'s Recall guidance, then keep going.\n',
-  );
-  process.exit(0);
-}
-
-writeState(sessionId, state);
-process.exit(0);