@agent-native/core 0.122.2 → 0.122.4

package/corpus/README.md

@@ -28,6 +28,6 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- core files: 1671
+- core files: 1674
 - toolkit files: 160
-- template files: 6470
+- template files: 6472

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @agent-native/core
 
+## 0.122.4
+
+### Patch Changes
+
+- 648c2d7: Install Rewind through Agent Native's complete local Screen Memory setup instead of treating it as a plain public skill, route every supported Rewind name through the same fail-before-writes checks, reject missing or disconnected local stores, keep explicit-store retrieval bound to Clips' feature configuration, and guide first-time users through consent-gated Clips Desktop setup.
+
+## 0.122.3
+
+### Patch Changes
+
+- 6dd7ee0: Recover long-running messaging integrations across hosted function boundaries while preserving one logical agent turn and one final platform reply.
+
 ## 0.122.2
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.122.2",
+  "version": "0.122.4",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/corpus/core/src/agent/run-loop-with-resume.ts

@@ -124,6 +124,18 @@ async function appendContinuationAndJournal(
   appendToolCallJournalNote(messages, events);
 }
 
+/**
+ * Rebuild the same safe continuation context for a logical turn that resumes
+ * in a fresh hosted invocation.
+ */
+export async function appendDurableContinuationContext(
+  messages: EngineMessage[],
+  reason: AgentLoopContinuationReason,
+  threadId: string,
+): Promise<void> {
+  await appendContinuationAndJournal(messages, reason, threadId);
+}
+
 async function hasCompletedSideEffectToolCallInCurrentTurn(
   threadId: string | undefined,
   localEvents: readonly AgentChatEvent[] = [],

package/corpus/core/src/cli/index.ts

@@ -9,6 +9,7 @@ import { fileURLToPath } from "url";
 import * as Sentry from "@sentry/node";
 
 import { resolveDeployPostBuildInvocation } from "./deploy-build.js";
+import { shouldTrackCliRun } from "./telemetry-routing.js";
 import { createCliTelemetry } from "./telemetry.js";
 
 // Resolve version once at module scope — used by both --version and --help
@@ -604,7 +605,7 @@ function runBuildStep(
   });
 }
 
-trackCli("cli.run");
+if (shouldTrackCliRun(command, args)) trackCli("cli.run");
 
 switch (command) {
   case "dev": {

package/corpus/core/src/cli/mcp.ts

@@ -92,6 +92,15 @@ export interface ScreenMemoryStoreResolutionOptions {
   homeDir?: string;
 }
 
+function existingScreenMemoryStore(candidate: string): string | undefined {
+  const resolved = path.resolve(candidate);
+  try {
+    return fs.statSync(resolved).isDirectory() ? resolved : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Resolve the active Clips store without asking people to find an app-data
  * path. Environment overrides remain the unambiguous escape hatch; otherwise
@@ -100,11 +109,12 @@ export interface ScreenMemoryStoreResolutionOptions {
 export function resolveScreenMemoryStoreDir(
   options: ScreenMemoryStoreResolutionOptions = {},
 ): string | undefined {
-  if (options.explicitDir) return path.resolve(options.explicitDir);
+  if (options.explicitDir)
+    return existingScreenMemoryStore(options.explicitDir);
   const env = options.env ?? process.env;
   const override =
     env.CLIPS_SCREEN_MEMORY_DIR || env.AGENT_NATIVE_SCREEN_MEMORY_DIR;
-  if (override) return path.resolve(override);
+  if (override) return existingScreenMemoryStore(override);
 
   const platform = options.platform ?? process.platform;
   const home = options.homeDir ?? os.homedir();
@@ -116,7 +126,7 @@ export function resolveScreenMemoryStoreDir(
         : env.XDG_DATA_HOME || path.join(home, ".local", "share");
   return ["com.clips.tray", "com.clips.tray.alpha"]
     .map((bundleId) => path.join(appDataRoot, bundleId, "screen-memory"))
-    .filter((candidate) => fs.existsSync(candidate))
+    .filter((candidate) => existingScreenMemoryStore(candidate))
     .map((candidate) => ({
       candidate,
       modifiedAt: Math.max(

package/corpus/core/src/cli/skills-content/rewind-skill.ts

@@ -13,6 +13,38 @@ metadata:
 Use Clips Rewind as local screen memory. Start broad enough to find the right
 moment, then read only the smallest relevant range.
 
+## First-Run Setup
+
+Call \`screen_memory_status\` before assuming Rewind is ready. If the tool is
+unavailable, do not stop at a missing-tool error and do not silently install
+anything:
+
+1. Explain that Rewind requires the signed Clips Desktop app on macOS plus a
+   local agent connection.
+2. Ask whether Clips is installed, or use a non-mutating native application
+   lookup when the host supports one. Do not inspect Clips' app-data folders.
+   If Clips is absent or its presence cannot be confirmed, ask permission
+   before opening or downloading anything: “Clips Desktop is required for
+   Rewind. Would you like me to open the official installer and guide you
+   through setup?”
+3. Only after affirmative permission, open
+   \`https://clips.agent-native.com/download\` in the user's browser. Complete
+   native installation steps only when the current host can safely do so and
+   the user explicitly permitted them. Never bypass Gatekeeper, accept macOS
+   permission prompts, or enable screen/audio capture on the user's behalf.
+4. If native UI control is unavailable, return the download link and wait for
+   the user to confirm that Clips is installed and running.
+5. Ask the user to enable Rewind in the Clips tray and choose the intended
+   capture mode. Then configure the local connection with:
+
+   \`npx -y @agent-native/core@latest skills add rewind --client <client> --scope user --yes\`
+
+   Replace \`<client>\` with the current compatible host: \`codex\`,
+   \`claude-code\`, \`cursor\`, \`opencode\`, \`github-copilot\`, or \`cowork\`.
+6. Restart the host only if it cannot reload MCP servers in place, then retry
+   \`screen_memory_status\`. Do not claim setup succeeded until it reports
+   Rewind enabled and unpaused.
+
 ## Retrieval Flow
 
 1. Call \`screen_memory_status\` first. If the newest segment is still open,
@@ -41,12 +73,12 @@ moment, then read only the smallest relevant range.
   bypass the Screen Memory MCP broker.
 - Do not upload frames returned by local Screen Memory tools.
 - Treat foreground apps and chapter labels as evidence, not proof of intent.
-- If the Screen Memory MCP is missing, explain that the one-time setup needs to
-  be repaired with:
+- If Clips is installed and Rewind is enabled but the Screen Memory MCP is
+  missing, explain that only the agent connection needs repair with:
 
   \`npx -y @agent-native/core@latest skills add rewind --client <client> --scope user --yes\`
 
-  Replace \`<client>\` with the current compatible host: \`codex\`,
-  \`claude-code\`, \`cursor\`, \`opencode\`, \`github-copilot\`, or \`cowork\`.
   Ask the user to restart the host if it cannot reload MCP servers in place.
+- Never conflate installing Clips Desktop with installing the skill/MCP
+  connection, and never claim either succeeded without direct evidence.
 `;

package/corpus/core/src/cli/skills.ts

@@ -32,7 +32,7 @@ import {
   CONTEXT_XRAY_SKILL_MD,
   installLocalContextXray,
 } from "./context-xray-local.js";
-import { CLIENTS, type ClientId } from "./mcp-config-writers.js";
+import { CLIENTS, configPathFor, type ClientId } from "./mcp-config-writers.js";
 import {
   installScreenMemoryForClient,
   resolveScreenMemoryStoreDir,
@@ -800,6 +800,7 @@ export interface RunSkillsOptions {
    * browser/device OAuth round-trip.
    */
   runConnect?: (args: string[]) => Promise<void>;
+  installScreenMemory?: typeof installScreenMemoryForClient;
   /**
    * Best-effort install-funnel telemetry. Created once per `runSkills` run and
    * threaded through resolution/install/connect so each `track` is fire-and-
@@ -850,6 +851,50 @@ function isKnownSkill(value: string | undefined): boolean {
   return Boolean(normalizeKnownSkillTarget(value));
 }
 
+function explicitlyTargetsRewind(parsed: ParsedSkillsArgs): boolean {
+  return (
+    normalizeKnownSkillTarget(parsed.target ?? "assets") === "rewind" ||
+    Boolean(
+      parsed.plainSkillNames?.some(
+        (skillName) => normalizeKnownSkillTarget(skillName) === "rewind",
+      ),
+    )
+  );
+}
+
+const REWIND_MISSING_STORE_ERROR =
+  "No local Clips Screen Memory store was found. Clips Desktop is required for Rewind. Download and launch the signed app from https://clips.agent-native.com/download, turn Rewind on, then run the setup again. Clips Desktop was not installed or enabled automatically.";
+
+function preflightRewindStore(parsed: ParsedSkillsArgs): string | undefined {
+  if (parsed.command !== "add" || !explicitlyTargetsRewind(parsed))
+    return undefined;
+  if (!parsed.mcp) {
+    throw new Error(
+      "Rewind requires the local Clips Screen Memory MCP and cannot be installed with --no-mcp.",
+    );
+  }
+  if (parsed.mcpUrl) {
+    throw new Error(
+      "Rewind uses the local Clips Screen Memory MCP and does not accept --mcp-url.",
+    );
+  }
+  if (parsed.dryRun) return undefined;
+  const screenMemoryDir = resolveScreenMemoryStoreDir();
+  if (!screenMemoryDir) throw new Error(REWIND_MISSING_STORE_ERROR);
+  return screenMemoryDir;
+}
+
+function preflightResolvedRewindTargets(
+  parsed: ParsedSkillsArgs,
+  targets: string[],
+): void {
+  preflightRewindStore({
+    ...parsed,
+    target: undefined,
+    plainSkillNames: [...(parsed.plainSkillNames ?? []), ...targets],
+  });
+}
+
 function isLocalOnlyBuiltInSkill(
   entry: (typeof BUILT_IN_APP_SKILLS)[BuiltInAppSkillId] | null | undefined,
 ): boolean {
@@ -1382,7 +1427,7 @@ $ARGUMENTS
  * there is no need to shell out to the separate @agent-native/skills installer
  * (which would have to be published to npm first). Returns the written folders.
  */
-function installBuiltInInstructions(input: {
+type BuiltInInstructionInstallInput = {
   appSkillId: BuiltInAppSkillId;
   onlySkillNames?: string[];
   skillsAgents: string[];
@@ -1391,7 +1436,11 @@ function installBuiltInInstructions(input: {
   dryRun?: boolean;
   planMode?: PlanInstallMode;
   mcpUrl?: string;
-}): string[] {
+};
+
+function builtInInstructionPaths(
+  input: BuiltInInstructionInstallInput,
+): string[] {
   const bundles = Object.values(
     skillFilesForBuiltIn(input.appSkillId, {
       planMode: input.planMode,
@@ -1411,15 +1460,10 @@ function installBuiltInInstructions(input: {
     );
     for (const bundle of bundles) {
       const dir = path.join(root, bundle.skillName);
-      if (!input.dryRun) writeSkillFolder(dir, bundle);
       written.push(dir);
       const command = slashCommandForBuiltInSkill(bundle.skillName);
       if (command) {
         const commandPath = path.join(commandsRoot, `${bundle.skillName}.md`);
-        if (!input.dryRun) {
-          fs.mkdirSync(path.dirname(commandPath), { recursive: true });
-          fs.writeFileSync(commandPath, command, "utf-8");
-        }
         written.push(commandPath);
       }
     }
@@ -1427,6 +1471,87 @@ function installBuiltInInstructions(input: {
   return written;
 }
 
+function installBuiltInInstructions(
+  input: BuiltInInstructionInstallInput,
+): string[] {
+  const bundles = Object.values(
+    skillFilesForBuiltIn(input.appSkillId, {
+      planMode: input.planMode,
+      mcpUrl: input.mcpUrl,
+    }),
+  ).filter(
+    (bundle) =>
+      !input.onlySkillNames || input.onlySkillNames.includes(bundle.skillName),
+  );
+  const written = builtInInstructionPaths(input);
+  if (input.dryRun) return written;
+
+  for (const agent of input.skillsAgents) {
+    const root = builtInSkillsRootForAgent(agent, input.scope, input.baseDir);
+    const commandsRoot = builtInCommandsRootForAgent(
+      agent,
+      input.scope,
+      input.baseDir,
+    );
+    for (const bundle of bundles) {
+      writeSkillFolder(path.join(root, bundle.skillName), bundle);
+      const command = slashCommandForBuiltInSkill(bundle.skillName);
+      if (command) {
+        const commandPath = path.join(commandsRoot, `${bundle.skillName}.md`);
+        fs.mkdirSync(path.dirname(commandPath), { recursive: true });
+        fs.writeFileSync(commandPath, command, "utf-8");
+      }
+    }
+  }
+  return written;
+}
+
+interface InstallPathSnapshot {
+  target: string;
+  backup: string;
+  existed: boolean;
+}
+
+function snapshotInstallPaths(
+  targets: string[],
+  backupRoot: string,
+): InstallPathSnapshot[] {
+  return [...new Set(targets)].map((target, index) => {
+    const backup = path.join(backupRoot, `snapshot-${index}`);
+    const existed = fs.existsSync(target);
+    if (existed) fs.cpSync(target, backup, { recursive: true });
+    return { target, backup, existed };
+  });
+}
+
+function removeEmptyParents(start: string, boundary: string): void {
+  let current = path.resolve(start);
+  const stop = path.resolve(boundary);
+  while (current !== stop && current.startsWith(`${stop}${path.sep}`)) {
+    if (!fs.existsSync(current) || fs.readdirSync(current).length > 0) return;
+    fs.rmdirSync(current);
+    current = path.dirname(current);
+  }
+}
+
+function restoreInstallPaths(
+  snapshots: InstallPathSnapshot[],
+  boundary: string,
+): void {
+  for (const snapshot of snapshots.toReversed()) {
+    fs.rmSync(snapshot.target, { recursive: true, force: true });
+    if (snapshot.existed) {
+      fs.mkdirSync(path.dirname(snapshot.target), { recursive: true });
+      fs.cpSync(snapshot.backup, snapshot.target, { recursive: true });
+    }
+  }
+  for (const snapshot of snapshots) {
+    if (!snapshot.existed) {
+      removeEmptyParents(path.dirname(snapshot.target), boundary);
+    }
+  }
+}
+
 function listSkillFolderFiles(dir: string): Record<string, string> {
   const out: Record<string, string> = {};
   const walk = (current: string, prefix = "") => {
@@ -3376,6 +3501,11 @@ export async function addAgentNativeSkill(
   const knownBuiltIn = knownTarget ? BUILT_IN_APP_SKILLS[knownTarget] : null;
   const installsScreenMemoryMcp = isScreenMemoryMcpBuiltInSkill(knownBuiltIn);
   const baseDir = options.baseDir ?? process.cwd();
+  if (installsScreenMemoryMcp && !parsed.mcp) {
+    throw new Error(
+      "Rewind requires the local Clips Screen Memory MCP and cannot be installed with --no-mcp.",
+    );
+  }
   if (installsScreenMemoryMcp && parsed.mcpUrl) {
     throw new Error(
       "Rewind uses the local Clips Screen Memory MCP and does not accept --mcp-url.",
@@ -3487,7 +3617,7 @@ export async function addAgentNativeSkill(
   }
   installTarget = preserveMcpUrlAppPathOverride(installTarget, parsed.mcpUrl);
   const skillsAgents = installsScreenMemoryMcp
-    ? clients
+    ? clients.filter((client) => client !== "cowork")
     : skillsAgentsForClients(clients);
   if (parsed.dryRun) {
     try {
@@ -3537,6 +3667,7 @@ export async function addAgentNativeSkill(
     }
   }
   const commands: string[] = [];
+  const screenMemoryDir = preflightRewindStore(parsed);
   const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "an-skills-add-"));
   let instructionSource: string | undefined;
   let instructionsWritten: string[] | undefined;
@@ -3544,6 +3675,36 @@ export async function addAgentNativeSkill(
   let connectCommand: string | undefined;
   let registeredMcpClients: ClientId[] = shouldRegisterMcp ? mcpClients : [];
   let localManifestPath: string | undefined;
+  const builtInInstructionInput: BuiltInInstructionInstallInput | undefined =
+    knownTarget
+      ? {
+          appSkillId: knownTarget,
+          onlySkillNames,
+          skillsAgents,
+          scope: parsed.scope as "project" | "user",
+          baseDir,
+          dryRun: parsed.dryRun,
+          planMode,
+          mcpUrl: installTarget.loaded.manifest.hosted.mcpUrl,
+        }
+      : undefined;
+  const rewindSnapshots = installsScreenMemoryMcp
+    ? snapshotInstallPaths(
+        [
+          ...(parsed.instructions && builtInInstructionInput
+            ? builtInInstructionPaths(builtInInstructionInput)
+            : []),
+          ...(shouldRegisterMcp
+            ? mcpClients.map((client) =>
+                configPathFor(client, baseDir, parsed.scope),
+              )
+            : []),
+        ],
+        tmpRoot,
+      )
+    : undefined;
+  const rollbackBoundary =
+    parsed.scope === "user" ? os.homedir() : path.resolve(baseDir);
 
   try {
     if (parsed.instructions) {
@@ -3553,21 +3714,14 @@ export async function addAgentNativeSkill(
             "Skill instructions use shared .agents for Codex, Pi, Cursor, OpenCode, Copilot, and similar agents, or Claude Code's native files. Use an MCP-capable client or omit --instructions-only.",
           );
         }
-      } else if (knownTarget) {
+      } else if (knownTarget && builtInInstructionInput) {
         // Built-in skills ship their instructions inside this package, so copy
         // the skill folders straight into each client's skills directory. This
         // avoids shelling out to the separate @agent-native/skills installer
         // (which would need to be published to npm to run via npx).
-        instructionsWritten = installBuiltInInstructions({
-          appSkillId: knownTarget,
-          onlySkillNames,
-          skillsAgents,
-          scope: parsed.scope as "project" | "user",
-          baseDir,
-          dryRun: parsed.dryRun,
-          planMode,
-          mcpUrl: installTarget.loaded.manifest.hosted.mcpUrl,
-        });
+        instructionsWritten = installBuiltInInstructions(
+          builtInInstructionInput,
+        );
         instructionSource = instructionsWritten[0];
         commands.push(...instructionsWritten.map((dir) => `write ${dir}`));
       } else {
@@ -3611,29 +3765,24 @@ export async function addAgentNativeSkill(
       commands.push(`write ${localManifestPath}`);
     }
 
-    // Skill instructions are now on disk (built-in folders copied or external
-    // pack materialized) — record the install before MCP registration/connect.
-    options.telemetry?.track("skills_cli install completed", {
-      skills: installTarget.skillNames.join(","),
-      clients: clients.join(","),
-      scope: parsed.scope,
-      dryRun: Boolean(parsed.dryRun),
-    });
+    // Rewind reports completion only after both local writes succeed.
+    if (!installsScreenMemoryMcp) {
+      options.telemetry?.track("skills_cli install completed", {
+        skills: installTarget.skillNames.join(","),
+        clients: clients.join(","),
+        scope: parsed.scope,
+        dryRun: Boolean(parsed.dryRun),
+      });
+    }
 
     if (shouldRegisterMcp && installsScreenMemoryMcp) {
-      const screenMemoryDir = resolveScreenMemoryStoreDir();
-      if (!screenMemoryDir) {
-        throw new Error(
-          "No local Clips Screen Memory store was found. Turn Rewind on in Clips, then run the setup again.",
-        );
-      }
       registeredMcpClients = mcpClients.map((client) => {
         commands.push(
           `npx @agent-native/core@latest mcp install-screen-memory --client ${client} --scope ${parsed.scope}`,
         );
-        installScreenMemoryForClient(
+        (options.installScreenMemory ?? installScreenMemoryForClient)(
           client,
-          screenMemoryDir,
+          screenMemoryDir!,
           baseDir,
           parsed.scope,
         );
@@ -3642,6 +3791,12 @@ export async function addAgentNativeSkill(
       options.telemetry?.track("skills_cli mcp registered", {
         skills: installTarget.skillNames.join(","),
       });
+      options.telemetry?.track("skills_cli install completed", {
+        skills: installTarget.skillNames.join(","),
+        clients: clients.join(","),
+        scope: parsed.scope,
+        dryRun: false,
+      });
     } else if (shouldRegisterMcp) {
       commands.push(
         `npx @agent-native/core@latest app-skill ensure --manifest ${installTarget.loaded.file} --client ${parsed.client} --scope ${parsed.scope} --yes`,
@@ -3769,6 +3924,18 @@ export async function addAgentNativeSkill(
       githubActionExisted,
       githubActionSuggestedCommand,
     };
+  } catch (error) {
+    if (rewindSnapshots) {
+      try {
+        restoreInstallPaths(rewindSnapshots, rollbackBoundary);
+      } catch (rollbackError) {
+        throw new AggregateError(
+          [error, rollbackError],
+          "Rewind setup failed and its partial installation could not be fully rolled back.",
+        );
+      }
+    }
+    throw error;
   } finally {
     fs.rmSync(tmpRoot, { recursive: true, force: true });
     installTarget.cleanup?.();
@@ -4046,6 +4213,41 @@ function readCliVersion(): string {
   }
 }
 
+function deferCliTelemetry(target: CliTelemetry): {
+  telemetry: CliTelemetry;
+  commit: () => void;
+} {
+  type TrackCall = Parameters<CliTelemetry["track"]>;
+  type ExceptionCall = Parameters<CliTelemetry["captureException"]>;
+  const trackCalls: TrackCall[] = [];
+  const exceptionCalls: ExceptionCall[] = [];
+  let committed = false;
+
+  return {
+    telemetry: {
+      track(...args) {
+        if (committed) target.track(...args);
+        else trackCalls.push(args);
+      },
+      captureException(...args) {
+        if (committed) target.captureException(...args);
+        else exceptionCalls.push(args);
+      },
+      async flush() {
+        if (committed) await target.flush();
+      },
+    },
+    commit() {
+      if (committed) return;
+      committed = true;
+      for (const args of trackCalls) target.track(...args);
+      for (const args of exceptionCalls) target.captureException(...args);
+      trackCalls.length = 0;
+      exceptionCalls.length = 0;
+    },
+  };
+}
+
 export async function runSkills(
   argv: string[],
   options: RunSkillsOptions = {},
@@ -4054,6 +4256,7 @@ export async function runSkills(
   if (parsed.baseDir) {
     options = { ...options, baseDir: path.resolve(parsed.baseDir) };
   }
+  preflightRewindStore(parsed);
   const clackForLog = parsed.printJson
     ? undefined
     : await import("@clack/prompts");
@@ -4089,7 +4292,7 @@ export async function runSkills(
   // finally so events send on success, error, and cancellation — the CLI is
   // short-lived, so flushing before exit is essential or the events never send.
   const startedAt = Date.now();
-  const telemetry =
+  const telemetryTarget =
     options.telemetry ??
     createCliTelemetry({
       cli: "core",
@@ -4097,6 +4300,13 @@ export async function runSkills(
       command: parsed.command,
       interactive: shouldPrompt(parsed, options),
     });
+  const deferredTelemetry = deferCliTelemetry(telemetryTarget);
+  const telemetry = deferredTelemetry.telemetry;
+  const deferUntilSkillSelection =
+    parsed.command === "add" &&
+    !parsed.target &&
+    !(parsed.plainSkillNames?.length ?? 0);
+  if (!deferUntilSkillSelection) deferredTelemetry.commit();
   const optionsWithTelemetry: RunSkillsOptions = {
     ...options,
     telemetry,
@@ -4137,9 +4347,12 @@ export async function runSkills(
 
     const targets = await resolveSkillTargets(parsed, optionsWithTelemetry);
     if (!targets) {
+      deferredTelemetry.commit();
       telemetry.track("skills_cli cancelled", { step: "skills" });
       return;
     }
+    preflightResolvedRewindTargets(parsed, targets);
+    deferredTelemetry.commit();
     const preselected = Boolean(parsed.target);
     telemetry.track("skills_cli skills selected", {
       selected: targets.join(","),

package/corpus/core/src/cli/telemetry-routing.ts

@@ -0,0 +1,57 @@
+const REWIND_SKILL_TARGETS = new Set([
+  "rewind",
+  "screen-memory",
+  "clips-rewind",
+  "agent-native-rewind",
+]);
+
+function isRewindSkillTarget(value: string | undefined): boolean {
+  return REWIND_SKILL_TARGETS.has(value?.trim().toLowerCase() ?? "");
+}
+
+const SKILLS_VALUE_FLAGS = new Set([
+  "--client",
+  "--agent",
+  "-a",
+  "--scope",
+  "--cwd",
+  "--mcp-url",
+  "--mode",
+]);
+
+function explicitSkillTargets(args: string[]): string[] {
+  const targets: string[] = [];
+  const start = args[0] === "add" ? 1 : 0;
+  for (let index = start; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--skill" || arg === "-s") {
+      if (args[index + 1]) targets.push(args[++index]);
+      continue;
+    }
+    if (arg.startsWith("--skill=")) {
+      targets.push(arg.slice("--skill=".length));
+      continue;
+    }
+    if (SKILLS_VALUE_FLAGS.has(arg)) {
+      index++;
+      continue;
+    }
+    if (arg.startsWith("-")) continue;
+    targets.push(arg);
+  }
+  return targets;
+}
+
+export function shouldTrackCliRun(command: string | undefined, args: string[]) {
+  if (command !== "skills") return true;
+  if (
+    ["list", "status", "update", "help", "--help", "-h"].includes(args[0] ?? "")
+  )
+    return true;
+
+  const targets = explicitSkillTargets(args);
+  if (targets.length === 0) return false;
+
+  const explicitlyTargetsRewind = targets.some(isRewindSkillTarget);
+  return !explicitlyTargetsRewind;
+}